【设计模式】状态模式

主页传送门：💁 传送

1.状态模式定义

       状态模式（State Pattern），又称状态对象模式（Pattern of Objects for States），状态模式是对象的行为模式。其定义如下：

Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.

       即：当一个对象内在状态改变时允许改变行为，这个对象看起来像改变了其类型。
       对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。
       其通用类图如下：

2.状态模式的角色

状态模式所涉及到的角色有：

• 环境(Context)角色：
  也成上下文：定义客户端所感兴趣的接口，并且保留一个具体状态类的实例。这个具体状态类的实例给出此环境对象的现有状态。
• 抽象状态(State)角色：
  定义一个接口，用以封装环境（Context）对象的一个特定的状态所对应的行为。
• 具体状态(ConcreteState)角色：
  每一个具体状态类都实现了环境（Context）的一个状态所对应的行为。

3.状态模式实战案例

3.1.场景说明

       考虑一个在线投票系统的应用，要实现控制同一个用户只能投一票，如果一个用户反复投票，而且投票次数超过5次，则判定为恶意刷票，要取消该用户投票的资格，当然同时也要取消他所投的票；如果一个用户的投票次数超过8次，将进入黑名单，禁止再登录和使用系统。
       要使用状态模式实现，首先需要把投票过程的各种状态定义出来，根据以上描述大致分为四种状态：正常投票、反复投票、恶意刷票、进入黑名单。然后创建一个投票管理对象（相当于Context）。

3.2.结构类图

       使用状态模式来实现的结构图如下所示：：

3.3.代码实现

抽象状态类

public interface VoteState {
    /**
     * 处理状态对应的行为
     * @param user    投票人
     * @param voteItem    投票项
     * @param voteManager    投票上下文，用来在实现状态对应的功能处理的时候，
     *                         可以回调上下文的数据
     */
    public void vote(String user,String voteItem,VoteManager voteManager);
}
1
2
3
4
5
6
7
8
9
10

具体状态类——正常投票

public class NormalVoteState implements VoteState {

    @Override
    public void vote(String user, String voteItem, VoteManager voteManager) {
        //正常投票，记录到投票记录中
        voteManager.getMapVote().put(user, voteItem);
        System.out.println("恭喜投票成功");
    }

}
1
2
3
4
5
6
7
8
9
10

具体状态类——重复投票

public class RepeatVoteState implements VoteState {

    @Override
    public void vote(String user, String voteItem, VoteManager voteManager) {
        //重复投票，暂时不做处理
        System.out.println("请不要重复投票");
    }

}
1
2
3
4
5
6
7
8
9

具体状态类——恶意刷票

public class SpiteVoteState implements VoteState {

    @Override
    public void vote(String user, String voteItem, VoteManager voteManager) {
        // 恶意投票，取消用户的投票资格，并取消投票记录
        String str = voteManager.getMapVote().get(user);
        if(str != null){
            voteManager.getMapVote().remove(user);
        }
        System.out.println("你有恶意刷屏行为，取消投票资格");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13

具体状态类——黑名单

public class BlackVoteState implements VoteState {

    @Override
    public void vote(String user, String voteItem, VoteManager voteManager) {
        //记录黑名单中，禁止登录系统
        System.out.println("进入黑名单，将禁止登录和使用本系统");
    }

}
1
2
3
4
5
6
7
8
9

环境类

public class VoteManager {
    //持有状体处理对象
    private VoteState state = null;
    //记录用户投票的结果，Map对应Map<用户名称，投票的选项>
    private Map<String,String> mapVote = new HashMap<String,String>();
    //记录用户投票次数，Map对应Map<用户名称，投票的次数>
    private Map<String,Integer> mapVoteCount = new HashMap<String,Integer>();
    /**
     * 获取用户投票结果的Map
     */
    public Map<String, String> getMapVote() {
        return mapVote;
    }
    /**
     * 投票
     * @param user    投票人
     * @param voteItem    投票的选项
     */
    public void vote(String user,String voteItem){
        //1.为该用户增加投票次数
        //从记录中取出该用户已有的投票次数
        Integer oldVoteCount = mapVoteCount.get(user);
        if(oldVoteCount == null){
            oldVoteCount = 0;
        }
        oldVoteCount += 1;
        mapVoteCount.put(user, oldVoteCount);
        //2.判断该用户的投票类型，就相当于判断对应的状态
        //到底是正常投票、重复投票、恶意投票还是上黑名单的状态
        if(oldVoteCount == 1){
            state = new NormalVoteState();
        }
        else if(oldVoteCount > 1 && oldVoteCount < 5){
            state = new RepeatVoteState();
        }
        else if(oldVoteCount >= 5 && oldVoteCount <8){
            state = new SpiteVoteState();
        }
        else if(oldVoteCount > 8){
            state = new BlackVoteState();
        }
        //然后转调状态对象来进行相应的操作
        state.vote(user, voteItem, this);
    }
}
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

客户端类

public class Client {

    public static void main(String[] args) {
        
        VoteManager vm = new VoteManager();
        for(int i=0;i<9;i++){
            vm.vote("u1","A");
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11

4.状态模式优缺点

状态模式的优点主要包括：

• 对状态转换规则进行了封装，使得状态转换逻辑与状态对象合为一体，简化了客户端代码。
• 扩展性好，方便新增状态，只需要改变对象状态就可以实现改变对象行为。
• 代码简洁，易于维护，每个状态类对应一个状态，结构清晰。

状态模式的缺点主要包括：

• 会增加系统中类或对象的个数。
• 结构与实现比较复杂，如果使用不当会导致程序结构和代码混乱。
• 对开闭原则的支持不够，每次增加新的状态类都需要修改原有代码。

5.状态模式适用场景

状态模式适用于以下场景：

1. 一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为。例如，一个游戏中的角色，其行为取决于它当前的状态（如健康状态、攻击状态等）。
2. 系统中存在多个状态，且状态之间需要转换。例如，一个订单的状态可以从“待付款”转换为“已付款”，再转换为“已发货”等。

在这些场景下，使用状态模式可以帮助我们将对象的行为与状态分离，使得代码更加清晰、易于维护。同时，状态模式也使得状态的转换逻辑更加明确，便于扩展和维护。

6.状态模式总结

     状态模式是一种行为设计模式，它允许一个对象在其内部状态改变时改变它的行为。通过将对象的状态和相关行为封装在对应的状态类中，状态模式使得代码更加清晰、易于维护。同时，状态模式也使得状态的转换逻辑更加明确，便于扩展和维护。在使用状态模式时，需要注意避免增加过多类或对象导致代码混乱，以及对开闭原则的支持问题。

如果喜欢的话，欢迎 🤞关注 👍点赞 💬评论 🤝收藏 🙌一起讨论
你的支持就是我✍️创作的动力！ 💞💞💞