设计模式（十八）之行为型模式-状态模式

发表于 | 阅读次数:
字数统计: 1.7k | 阅读时长 ≈ 7

一、状态模式

1、案例

1.1 APP抽奖活动问题

编写程序完成APP抽奖活动，具体要求如下：

（1）加入每参加一次这个活动要扣除用户50积分，中奖概率是10%

（2）奖品数量固定，抽完就不能抽奖

（3）活动有4个状态：可以抽奖、不能抽奖、发放奖品和奖品领完

2、状态模式基本介绍

2.1 基本介绍

（1）状态模式（State Pattern）：它主要用来解决对象在多种状态转换时，需要对外输出不同的行为的问题。状态和行为是一一对应的，状态之间可以相互转换。

（2）当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类。

2.2 原理类图

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

image-20210815162448888

3、状态模式解决APP抽奖问题

3.1 实例类图

Activity类包含所有的状态对象，各个状态子类也含有Activity对象

image-20210815162435683

3.2 代码

3.2.1 State抽象类

1
2
3
4
5
6
7
8
9
10
11
12
// 这是一个抽象类，也可以是一个接口
public abstract class State {

    // 扣除积分
    public abstract void detuctMoney();

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

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

3.2.2 RaffleActivity类

该类和 四种状态类 相互内聚

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
public class RaffleActivity {

    // state 表示活动当前的状态，是变化的
    State state = null;

    // 奖品数量
    int count = 0;

    //四个属性，表示四种状态
    State noRaffleState = new NoRaffleState(this);
    State canRaffleState = new CanRaffleState(this);
    State dispenseState = new DispenseState(this);
    State dispenseOutState = new DispenseOutState(this);

    // 初始化当前的状态为NoRaffleState（即不能抽奖的状态）
    // 初始化奖品的数量
    public RaffleActivity(int count) {
        this.state = getNoRaffleState();
        this.count = count;
    }

    public State getState() {
        return state;
    }

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

    // 这里要注意：每领取一次奖品，Count--
    public int getCount() {
        int curCount = count;
        count--;
        return curCount;
    }

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

    public State getNoRaffleState() {
        return noRaffleState;
    }

    public void setNoRaffleState(State noRaffleState) {
        this.noRaffleState = noRaffleState;
    }

    public State getCanRaffleState() {
        return canRaffleState;
    }

    public void setCanRaffleState(State canRaffleState) {
        this.canRaffleState = canRaffleState;
    }

    public State getDispenseState() {
        return dispenseState;
    }

    public void setDispenseState(State dispenseState) {
        this.dispenseState = dispenseState;
    }

    public State getDispenseOutState() {
        return dispenseOutState;
    }

    public void setDispenseOutState(State dispenseOutState) {
        this.dispenseOutState = dispenseOutState;
    }

    // 扣分，调用当前状态的debuctMoney
    public void debuctMoney(){
        state.detuctMoney();
    }

    // 抽奖
    public void raffle(){
        // 如果当前的状态是抽奖成功
        if(state.raffle()){
            // 领取奖品
            state.dispensePrize();
        }
    }
}

3.2.3 NoRaffleState类

不能抽奖

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
// 不能抽奖的状态
public class NoRaffleState extends State{

    // 初始化时传入活动引用，扣除积分后改变其状态
    RaffleActivity raffleActivity;

    public NoRaffleState(RaffleActivity raffleActivity) {
        this.raffleActivity = raffleActivity;
    }

    // 当前状态是可以扣积分的，扣除积分后将状态变为可抽奖状态
    @Override
    public void detuctMoney() {
        System.out.println(" 扣除50积分成功，你可以抽奖了 ");
        raffleActivity.setState(raffleActivity.getCanRaffleState());
    }

    // 当前状态不能抽奖
    @Override
    public boolean raffle() {
        System.out.println(" 扣了积分才能抽奖 ");
        return false;
    }

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

3.2.4 CanRaffleState类

可以抽奖的状态

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
import java.util.Random;

// 可以抽奖的状态
public class CanRaffleState extends State{

    // 初始化时传入活动引用，扣除积分后改变其状态
    RaffleActivity raffleActivity;

    public CanRaffleState(RaffleActivity raffleActivity) {
        this.raffleActivity = raffleActivity;
    }

    // 已经扣除了几分，不能再扣
    @Override
    public void detuctMoney() {
        System.out.println(" 已经扣取过了积分 ");
    }

    // 可以抽奖，抽完奖后，根据实际情况，改成新的状态
    @Override
    public boolean raffle() {
        System.out.println(" 正在抽奖，请稍等！ ");
        Random r = new Random();
        int num = r.nextInt(10);
        // 10%中奖机会
        if(num == 0){
            // 改变活动状态为发放奖品 context
            raffleActivity.setState(raffleActivity.getDispenseState());
            return true;
        }else{
            System.out.println(" 很遗憾没有抽中奖品！ ");
            raffleActivity.setState(raffleActivity.getNoRaffleState());
            return false;
        }
    }

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

3.2.5 DispenseState类

发放奖品类

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
// 发放奖品的状态
public class DispenseState extends State{

    // 初始化时传入活动引用，扣除积分后改变其状态
    RaffleActivity raffleActivity;

    public DispenseState(RaffleActivity raffleActivity) {
        this.raffleActivity = raffleActivity;
    }

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

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

    // 发放奖品
    @Override
    public void dispensePrize() {
        if(raffleActivity.getCount() > 0){
            System.out.println(" 恭喜中奖了 ");
            // 改变状态为不能抽奖
            raffleActivity.setState(raffleActivity.getNoRaffleState());
        }else{
            System.out.println(" 很遗憾，奖品发送完了 ");
            // 改变状态为奖品发送完毕，后面我们不可以抽奖
            raffleActivity.setState(raffleActivity.getDispenseOutState());
            System.exit(0);
        }
    }
}

3.2.6 DispenseOutState类

奖品发放完毕

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
// 奖品发放完毕
// 当raffleActivity状态改变成DispenseOutState，抽奖活动结束
public class DispenseOutState extends State{

    // 初始化时传入活动引用，扣除积分后改变其状态
    RaffleActivity raffleActivity;

    public DispenseOutState(RaffleActivity raffleActivity) {
        this.raffleActivity = raffleActivity;
    }

    @Override
    public void detuctMoney() {
        System.out.println(" 奖品发送完了，请下次再参加 ");
    }

    @Override
    public boolean raffle() {
        System.out.println(" 奖品发送完了，请下次再参加 ");
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println(" 奖品发送完了，请下次再参加 ");
    }
}

3.2.7 Client类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Client {
    public static void main(String[] args) {
        // 创建活动对象，奖品有1个奖品
        RaffleActivity raffleActivity = new RaffleActivity(1);

        // 我们连续抽300次
        for(int i = 0;i < 300;i++){
            System.out.println("------第"+(i+1)+"次抽奖---------");
            //参加抽奖，第一步点击扣除积分
            raffleActivity.debuctMoney();
            //第二步抽奖
            raffleActivity.raffle();
        }
    }
}

结果：

image-20210815212839869

image-20210815213005977

image-20210815213027044

4、状态模式的注意事项和细节

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