跳转至

状态模式

分类：行为型模式。来源：《Head First 设计模式》第 10 章。

策略模式是围绕可以互换的算法来创建成功业务的。然而，状态走的是更崇高的路，它通过改变对象内部的状态来帮助对象控制自己的行为。

类结构

classDiagram
    direction TB
    class Context {
        +request()
        +setState(State state)
    }
    class State {
        <<interface>>
        +handle(Context context)
    }
    class ConcreteStateA {
        +handle(Context context)
    }
    class ConcreteStateB {
        +handle(Context context)
    }
    Context --> State : 当前状态
    State <|.. ConcreteStateA
    State <|.. ConcreteStateB
    State ..> Context : 请求状态切换

角色定义

角色 定义
Context（上下文） 保存当前状态，将请求委托给状态对象，并提供切换状态的操作。
State（状态接口） 定义各状态处理请求时使用的公共操作。
ConcreteStateA / ConcreteStateB（具体状态） 实现各自状态下的行为。图中具体状态可以根据条件调用上下文的 setState()；状态切换也可以由上下文负责。

原书笔记

糖果机

糖果机状态流转

stateDiagram-v2
    direction LR
    state InitialStock <<choice>>
    state "没有25分钱" as NoQuarter
    state "有25分钱" as HasQuarter
    state "售出糖果" as Sold
    state "糖果售罄" as SoldOut

    [*] --> InitialStock
    InitialStock --> NoQuarter: 初始库存大于0
    InitialStock --> SoldOut: 初始库存为0
    NoQuarter --> HasQuarter: 投入25分钱
    HasQuarter --> NoQuarter: 退回25分钱
    HasQuarter --> Sold: 转动曲柄
    Sold --> NoQuarter: 发放糖果，仍有库存
    Sold --> SoldOut: 发放最后一颗糖果

图中四个具名状态对应糖果机的四种工作状态，菱形节点用于判断初始库存。这里展示基础购买流程中的有效转换；例如未投币时转动曲柄，只输出提示，状态保持不变。

1.找出所有的状态

  • 没有25分钱
  • 有25分钱
  • 糖果售罄
  • 售出糖果

2.接下来，创建一个实例变量来持有目前的状态，然后定义每个状态的值：

1
2
3
4
5
final static int SOLD_OUT = 0;//售罄
final static int NO_QUARTER = 1;
final static int HAS_QUARTER = 2;
final static int SOLD = 3;//售出
int state = SOLD_OUT;//当前状态

3.创建一个状态机类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public void insertQuarter(){
    if(state == HAS_QUARTER) {
        System.out.println("You can't insert another quarter");
    } else if (state == SOLD_OUT) {
        System.out.println("You can't insert a quarter, the machine is sold out");
    } else if (state == SOLD) {
        System.out.println("Please wait,we're already giving you a gumball");
    } else if (state == NO_QUARTER) {
        state = HAS_QUARTER;
        System.out.println("You inserted a quarter");
    }
}

糖果机GumballMachine

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
public class GumballMachine {
    final static int SOLD_OUT = 0;//售罄
    final static int NO_QUARTER = 1;
    final static int HAS_QUARTER = 2;
    final static int SOLD = 3;//售出
    int state = SOLD_OUT;//当前状态
    int count = 0;

    public GumballMachine(int count) {
        this.count = count;
        if (count > 0) {
            state = NO_QUARTER;
        }
    }
    //当有25分钱投进来,就会执行这里...
    public void insertQuarter(){
        if(state == HAS_QUARTER) {
            System.out.println("You can't insert another quarter");
        } else if (state == SOLD_OUT) {
            System.out.println("You can't insert a quarter, the machine is sold out");
        } else if (state == SOLD) {
            System.out.println("Please wait,we're already giving you a gumball");
        } else if (state == NO_QUARTER) {
            System.out.println("You inserted a quarter");
            state = HAS_QUARTER;
        }
    }
    //现在,如果顾客试着退回25分钱
    public void ejectQuarter(){
        if(state == HAS_QUARTER) {//如果有25分钱,就把钱退回来,回到没有25分钱的状态。
            System.out.println("Quarter returned");
            state = NO_QUARTER;
        } else if (state == SOLD_OUT) {//如果没有25分钱的话,当然不能退回25分钱
            System.out.println("You haven't inserted a quarter");
        } else if (state == SOLD) {
            //如果顾客已经转动曲柄,就不能在退钱了,他已经拿到糖果了
            System.out.println("Sorry,you already turned the crank");
        } else if (state == NO_QUARTER) {
            //如果糖果售罄,就不可能接受25分钱,当然也不可能退钱。
            System.out.println("You can't eject,you haven't inserted a quarter yet");
        }
    }
    //顾客试着转动曲柄
    public void turnCrank(){
        if(state == SOLD) {
            System.out.println("Turning twice doesn't get you another gumball!");
        } else if (state == NO_QUARTER) {//
            System.out.println("You turned but there's no quarter");
        } else if (state == SOLD_OUT) {
            System.out.println("You turned,but there are no gumballs");
        } else if (state == HAS_QUARTER) {
            System.out.println("You turned...");
            state = SOLD;
            dispense();
        }
    }
    //调用此方法发放糖果
    public void dispense(){
        if(state == SOLD) {
            System.out.println("A gumball comes rolling out the slot");
            count = count -1;
            if(count==0){
                System.out.println("Oops, out of gumballs!");
                state = SOLD_OUT;
            }else{
                state = NO_QUARTER;
            }
        } else if (state == NO_QUARTER) {
            System.out.println("You need to pay first");
        } else if (state == SOLD_OUT) {
            System.out.println("No gumball dispensed");
        } else if (state == HAS_QUARTER) {
            System.out.println("No gumball dispensed");
        }
    }

    public void refill(int numGumBalls) {
        this.count = numGumBalls;
        state = NO_QUARTER;
    }

    public String toString() {
        StringBuffer result = new StringBuffer();
        result.append("\nMighty Gumball, Inc.");
        result.append("\nJava-enabled Standing Gumball Model #2004\n");
        result.append("Inventory: " + count + " gumball");
        if (count != 1) {
            result.append("s");
        }
        result.append("\nMachine is ");
        if (state == SOLD_OUT) {
            result.append("sold out");
        } else if (state == NO_QUARTER) {
            result.append("waiting for quarter");
        } else if (state == HAS_QUARTER) {
            result.append("waiting for turn of crank");
        } else if (state == SOLD) {
            result.append("delivering a gumball");
        }
        result.append("\n");
        return result.toString();
    }
}
测试：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class GumballMachineTestDrive {

    public static void main(String[] args) {
        GumballMachine gumballMachine = new GumballMachine(5);

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.ejectQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.ejectQuarter();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);
    }
}

输出结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 5 gumballs
Machine is waiting for quarter

You inserted a quarter
You turned...
A gumball comes rolling out the slot

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 4 gumballs
Machine is waiting for quarter

You inserted a quarter
Quarter returned
You turned but there's no quarter

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 4 gumballs
Machine is waiting for quarter

You inserted a quarter
You turned...
A gumball comes rolling out the slot
You inserted a quarter
You turned...
A gumball comes rolling out the slot
You can't eject,you haven't inserted a quarter yet

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 2 gumballs
Machine is waiting for quarter

You inserted a quarter
You can't insert another quarter
You turned...
A gumball comes rolling out the slot
You inserted a quarter
You turned...
A gumball comes rolling out the slot
Oops, out of gumballs!
You can't insert a quarter, the machine is sold out
You turned,but there are no gumballs

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 0 gumballs
Machine is sold out

变更需求：当曲柄被转动时，有10%的机会掉下来的是两个糖果。

新的设计

1.首先我们定义一个State接口，在这个接口内，糖果机的每个动作都有一个对应的方法。 2.然后为机器中的每个状态实现状态类。这些类将负责在对应的状态下进行机器的行为。 3.最后，我们要摆脱旧的条件代码，取而代之的方式是，将动作委托到状态类。

状态接口与具体状态

classDiagram
    direction TB
    class State {
        <<interface>>
        +insertQuarter()
        +ejectQuarter()
        +turnCrank()
        +dispense()
    }
    class SoldState {
        +insertQuarter()
        +ejectQuarter()
        +turnCrank()
        +dispense()
    }
    class SoldOutState {
        +insertQuarter()
        +ejectQuarter()
        +turnCrank()
        +dispense()
    }
    class NoQuarterState {
        +insertQuarter()
        +ejectQuarter()
        +turnCrank()
        +dispense()
    }
    class HasQuarterState {
        +insertQuarter()
        +ejectQuarter()
        +turnCrank()
        +dispense()
    }
    State <|.. SoldState
    State <|.. SoldOutState
    State <|.. NoQuarterState
    State <|.. HasQuarterState

新的”赢家“状态，实现State接口。

新增赢家状态

classDiagram
    direction TB
    class State {
        <<interface>>
        +insertQuarter()
        +ejectQuarter()
        +turnCrank()
        +dispense()
    }
    class WinnerState {
        +insertQuarter()
        +ejectQuarter()
        +turnCrank()
        +dispense()
    }
    State <|.. WinnerState

实现状态类

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
public class NoQuarterState implements State {
    GumballMachine gumballMachine;

    public NoQuarterState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    public void insertQuarter() {
        System.out.println("You inserted a quarter");
        gumballMachine.setState(gumballMachine.getHasQuarterState());
    }

    public void ejectQuarter() {
        System.out.println("You haven't inserted a quarter");
    }

    public void turnCrank() {
        System.out.println("You turned, but there's no quarter");
     }

    public void dispense() {
        System.out.println("You need to pay first");
    } 

    public void refill() { }

    public String toString() {
        return "waiting for quarter";
    }
}
public class HasQuarterState implements State {
    GumballMachine gumballMachine;

    public HasQuarterState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    public void insertQuarter() {
        System.out.println("You can't insert another quarter");
    }

    public void ejectQuarter() {
        System.out.println("Quarter returned");
        gumballMachine.setState(gumballMachine.getNoQuarterState());
    }

    public void turnCrank() {
        System.out.println("You turned...");
        gumballMachine.setState(gumballMachine.getSoldState());
    }

    public void dispense() {
        System.out.println("No gumball dispensed");
    }

    public void refill() { }

    public String toString() {
        return "waiting for turn of crank";
    }
}
public class SoldOutState implements State {
    GumballMachine gumballMachine;

    public SoldOutState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    public void insertQuarter() {
        System.out.println("You can't insert a quarter, the machine is sold out");
    }

    public void ejectQuarter() {
        System.out.println("You can't eject, you haven't inserted a quarter yet");
    }

    public void turnCrank() {
        System.out.println("You turned, but there are no gumballs");
    }

    public void dispense() {
        System.out.println("No gumball dispensed");
    }

    public void refill() { 
        gumballMachine.setState(gumballMachine.getNoQuarterState());
    }

    public String toString() {
        return "sold out";
    }
}

public class SoldState implements State {

    GumballMachine gumballMachine;

    public SoldState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    public void insertQuarter() {
        System.out.println("Please wait, we're already giving you a gumball");
    }

    public void ejectQuarter() {
        System.out.println("Sorry, you already turned the crank");
    }

    public void turnCrank() {
        System.out.println("Turning twice doesn't get you another gumball!");
    }

    public void dispense() {
        gumballMachine.releaseBall();
        if (gumballMachine.getCount() > 0) {
            gumballMachine.setState(gumballMachine.getNoQuarterState());
        } else {
            System.out.println("Oops, out of gumballs!");
            gumballMachine.setState(gumballMachine.getSoldOutState());
        }
    }

    public void refill() { }

    public String toString() {
        return "dispensing a gumball";
    }
}

重新改造糖果机

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
public class GumballMachine {

    State soldOutState;
    State noQuarterState;
    State hasQuarterState;
    State soldState;

    State state;
    int count = 0;

    public GumballMachine(int numberGumballs) {
        soldOutState = new SoldOutState(this);
        noQuarterState = new NoQuarterState(this);
        hasQuarterState = new HasQuarterState(this);
        soldState = new SoldState(this);

        this.count = numberGumballs;
        if (numberGumballs > 0) {
            state = noQuarterState;
        } else {
            state = soldOutState;
        }
    }

    public void insertQuarter() {
        state.insertQuarter();
    }

    public void ejectQuarter() {
        state.ejectQuarter();
    }

    public void turnCrank() {
        state.turnCrank();
        state.dispense();
    }

    void releaseBall() {
        System.out.println("A gumball comes rolling out the slot...");
        if (count != 0) {
            count = count - 1;
        }
    }

    int getCount() {
        return count;
    }

    void refill(int count) {
        this.count += count;
        System.out.println("The gumball machine was just refilled; it's new count is: " + this.count);
        state.refill();
    }

    void setState(State state) {
        this.state = state;
    }
    public State getState() {
        return state;
    }

    public State getSoldOutState() {
        return soldOutState;
    }

    public State getNoQuarterState() {
        return noQuarterState;
    }

    public State getHasQuarterState() {
        return hasQuarterState;
    }

    public State getSoldState() {
        return soldState;
    }

    public String toString() {
        StringBuffer result = new StringBuffer();
        result.append("\nMighty Gumball, Inc.");
        result.append("\nJava-enabled Standing Gumball Model #2004");
        result.append("\nInventory: " + count + " gumball");
        if (count != 1) {
            result.append("s");
        }
        result.append("\n");
        result.append("Machine is " + state + "\n");
        return result.toString();
    }
}

测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class GumballMachineTestDrive {

    public static void main(String[] args) {
        GumballMachine gumballMachine = new GumballMachine(2);

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        gumballMachine.refill(5);
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);
    }
}

定义状态模式

状态模式允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

WinnerState

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
public class WinnerState implements State {
    GumballMachine gumballMachine;

    public WinnerState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    public void insertQuarter() {
        System.out.println("Please wait, we're already giving you a Gumball");
    }

    public void ejectQuarter() {
        System.out.println("Please wait, we're already giving you a Gumball");
    }

    public void turnCrank() {
        System.out.println("Turning again doesn't get you another gumball!");
    }

    public void dispense() {
        gumballMachine.releaseBall();
        if (gumballMachine.getCount() == 0) {
            gumballMachine.setState(gumballMachine.getSoldOutState());
        } else {
            gumballMachine.releaseBall();
            System.out.println("YOU'RE A WINNER! You got two gumballs for your quarter");
            if (gumballMachine.getCount() > 0) {
                gumballMachine.setState(gumballMachine.getNoQuarterState());
            } else {
                System.out.println("Oops, out of gumballs!");
                gumballMachine.setState(gumballMachine.getSoldOutState());
            }
        }
    }

    public void refill() { }

    public String toString() {
        return "despensing two gumballs for your quarter, because YOU'RE A WINNER!";
    }
}

public class GumballMachine {

    State soldOutState;
    State noQuarterState;
    State hasQuarterState;
    State soldState;
    State winnerState;//加进一个新的WinnerState状态，然后在构造器中将它初始化
    //...
}

public class HasQuarterState implements State {
    Random randomWinner = new Random(System.currentTimeMillis());
    GumballMachine gumballMachine;

    public HasQuarterState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    public void insertQuarter() {
        System.out.println("You can't insert another quarter");
    }

    public void ejectQuarter() {
        System.out.println("Quarter returned");
        gumballMachine.setState(gumballMachine.getNoQuarterState());
    }

    public void turnCrank() {
        System.out.println("You turned...");
        int winner = randomWinner.nextInt(10);
        if ((winner == 0) && (gumballMachine.getCount() > 1)) {
            gumballMachine.setState(gumballMachine.getWinnerState());
        } else {
            gumballMachine.setState(gumballMachine.getSoldState());
        }
    }

    public void dispense() {
        System.out.println("No gumball dispensed");
    }

    public void refill() { }

    public String toString() {
        return "waiting for turn of crank";
    }
}
public class GumballMachineTestDrive {

    public static void main(String[] args) {
        GumballMachine gumballMachine = 
            new GumballMachine(10);

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);
    }
}

Head First 示例：带赢家奖励的糖果机

第 10 章将糖果机的投币、退币、转动曲柄和出糖行为交给状态对象。本节按作者 2020 年第二版配套源码的 state/gumballstatewinner 补齐“糖果机与状态对象如何协作”的类结构，包括投一次币获得两颗糖的赢家状态。

GumballMachine 同时保存各具体状态实例和当前状态引用。图中只画当前状态及两个代表性的回指关系；五个具体状态在源码中都持有糖果机引用。接口上的 refill() 是这一源码版本的补货操作，和前文历史四操作图属于不同阶段。

示例类型 模式角色 职责
GumballMachine 上下文 保存库存、当前状态和各状态实例，委托外部请求并提供切换与出糖方法。
State 状态接口 统一投币、退币、转动、发放与补货时的行为。
NoQuarterState 未投币状态 接收硬币后切换到已投币状态。
HasQuarterState 已投币状态 退币或处理转动；根据随机结果及库存决定普通出糖或赢家奖励。
SoldState 普通出糖状态 发出一颗糖，再根据库存切换到等待投币或售罄。
WinnerState 赢家状态 发出奖励糖果，并处理库存耗尽的情况。
SoldOutState 售罄状态 拒绝购买相关操作，在补货后转回等待投币状态。

示例 UML

classDiagram
    direction TB
    class GumballMachine {
        State state
        int count
        +insertQuarter()
        +ejectQuarter()
        +turnCrank()
        setState(State state)
        releaseBall()
        refill(int count)
    }
    class State {
        <<interface>>
        +insertQuarter()
        +ejectQuarter()
        +turnCrank()
        +dispense()
        +refill()
    }
    class NoQuarterState
    class HasQuarterState
    class SoldState
    class WinnerState
    class SoldOutState
    GumballMachine --> State : 当前状态
    State <|.. NoQuarterState
    State <|.. HasQuarterState
    State <|.. SoldState
    State <|.. WinnerState
    State <|.. SoldOutState
    HasQuarterState --> GumballMachine : 查询库存并切换
    WinnerState --> GumballMachine : 发放奖励并切换

协作过程

  1. 投入硬币时，糖果机委托当前的 NoQuarterState 处理，状态切换为 HasQuarterState。
  2. 转动曲柄时，已投币状态生成随机结果；命中赢家条件且库存大于一颗时切换到 WinnerState，否则转到 SoldState。
  3. GumballMachine.turnCrank() 在调用状态的 turnCrank() 后，继续调用**新的当前状态**的 dispense()。
  4. 普通状态发一颗、赢家状态按奖励规则发两颗，随后根据剩余库存切回等待投币或售罄状态。

配套源码（2020 年第二版，固定版本）：

评论