状态模式

抽奖活动问题

1. 加入每参加一次抽奖活动要扣除用户50积分，中奖概率是10%
2. 奖品数量固定，抽完就不能抽奖
3. 活动有四个状态：可以抽奖，不能抽奖，发放奖品，奖品领完
4. 活动状态转换关系：
   

状态模式

基本介绍

1. 状态模式主要用来解决对象在多种状态转换时，需要对外输出不同的行为的问题，状态和行为是一一对应的，状态之间可以相互转换
2. 当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了类

原理

1. Context：上下文环境角色，用于维护State实例，这个实例定义当前状态
2. State：抽象状态角色，定义一个接口与Context的一个特定接口相关行为
3. ConcreteState：具体的状态角色，每个子类实现一个与Context的状态相关行为

状态模式解决抽奖问题

/***
 * @author shaofan
 * @Description 状态模式解决抽奖问题
 */
public class LuckDraw {
    public static void main(String[] args) {
        Activity activity = new Activity(2);
        // 只用通过activity对活动流程进行调用，每个流程阶段执行完之后都会将activity内部的state改变，然后activity根据不同的state来完成不同的行为
        for (int i = 0; i < 100; i++) {
            activity.deductScore();
            if(activity.raffle()){
                activity.dispensePrize();
            }
        }

    }
}
class Activity{
    private int count;
    public Activity(int count){
        this.count = count;
        state = noRaffleState;
    }
    /**
     * 当前状态
     */
    private State state;
    private State noRaffleState = new NoRaffleState(this);
    private State canRaffleState = new CanRaffleState(this);
    private State dispenseState = new DispenseState(this);
    private State dispenseOutState = new DispenseOutState(this);

    public void toNoRaffleState() {
        state = noRaffleState;
    }

    public void toCanRaffleState(){
        state = canRaffleState;
    }

    public void toDispenseState(){
        state = dispenseState;
    }

    public void toDispenseOutState(){
        state = dispenseOutState;
    }

    public int getCount(){
        return count;
    }
    public void setCount(int count){
        this.count = count;
    }

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

    public boolean raffle(){
        return state.raffle();
    }

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

}
abstract class State{
    /**
     * 扣除积分
     */
    public abstract void deductScore();

    /**
     * 是否抽中奖品
     * @return
     */
    public abstract boolean raffle();

    /**
     * 发放奖品
     */
    public abstract void dispensePrize();

}

/***
 * 没有扣除积分，不能抽奖的状态
 */
class NoRaffleState extends State{
    private final Activity activity;
    public NoRaffleState(Activity activity){
        this.activity = activity;
    }

    @Override
    public void deductScore() {
        System.out.println("扣除了50积分，您现在可以抽奖了");
        activity.toCanRaffleState();
    }

    @Override
    public boolean raffle() {
        System.out.println("没有扣除积分，不能抽奖");
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("不能发放奖品");
    }
}

class CanRaffleState extends State{
    private final Activity activity;
    public CanRaffleState(Activity activity){
        this.activity = activity;
    }

    @Override
    public void deductScore() {
        System.out.println("已经扣取了积分");
    }

    @Override
    public boolean raffle() {
        System.out.println("正在抽奖，请稍等");
        Random random = new Random();
        int num = random.nextInt(10);
        if(num == 0){
            activity.toDispenseState();
            return true;
        }
        activity.toNoRaffleState();
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("抽奖未结束，不能发放奖品");
    }
}

class DispenseState extends State{
    private final Activity activity;
    public DispenseState(Activity activity){
        this.activity = activity;
    }

    @Override
    public void deductScore() {
        System.out.println("不能扣除积分");
    }

    @Override
    public boolean raffle() {
        System.out.println("不能抽奖");
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("正在发放奖品");
        if(activity.getCount()>0){
            activity.toNoRaffleState();
            activity.setCount(activity.getCount()-1);
        }else{
            activity.toDispenseOutState();
        }
    }
}

class DispenseOutState extends State{
    private Activity activity;
    public DispenseOutState(Activity activity){
        this.activity = activity;
    }

    @Override
    public void deductScore() {
        System.out.println("不能扣除积分");
    }

    @Override
    public boolean raffle() {
        System.out.println("不能抽奖");
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("奖品已经发放完，请等待下一次活动");
    }
}
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195

总结

1. 状态模式的代码具有很强的可读性，状态模式将每个状态的行为封装到对应的一个类中
2. 方便维护，将容易长生问题的if-else语句删除了，如果把每个状态的行为都放到一个类中，每次调用方法都要判断当前是什么状态，不但会产出很多的if-else语句，而且容易出错
3. 符合开闭原则，容易增删状态
4. 会产生很多类，每个状态都要对应一个类，当状态过多时会产生很多类，加大了维护难度
5. 当一个时间或者对象有很多种状态，状态之间会相互转换，对不同的状态有不同的行为的时候，可以考虑使用状态模式