Java设计模式——状态模式【State Pattern】

男娘i 2022-09-10 10:12 189阅读 0赞

## 一、引言 ##

23种设计模式大概分为三大类：

5种（创建型模式）：工厂方法模式、抽象工厂模式、单例模式、原型模式、建造者模式。

7种（结构型模式）：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

11种（行为型模式）：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

行为型又可以通过类与类之间的关系进行划分 :  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70]

状态模式基本介绍：

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

## 二、状态模式 ##

### 1.状态模式原理类图 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5q2i5q2l5YmN6KGM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

对原理类图的说明：

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

## 三、具体需求 ##

### 1.APP抽奖活动 ###

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

*  假如每参加一次这个活动要扣除用户 50 积分，中奖概率是 10%
 *  奖品数量固定，抽完就不能抽奖
 *  活动有四个状态: 可以抽奖、不能抽奖、发放奖品和奖品领完
 *  活动的四个状态转换关系图(下图)(如图：奖品领完就不能再抽奖，因为“奖品领完”的节点没有后续节点)

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5q2i5q2l5YmN6KGM_size_18_color_FFFFFF_t_70_g_se_x_16_pic_center]

### 2. 状态模式方案 ###

思路分析 - 类图

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5q2i5q2l5YmN6KGM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]  
说明：

*  定义一个接口叫状态接口，每个状态都实现它
 *  接口有扣除积分方法、抽奖方法、发放奖品方法
 *  Activity类就相当于Context

具体实现

//状态抽象类 State.java
    public abstract class State { 
    	// 扣除积分 - 50
        public abstract void deductMoney();
        // 是否抽中奖品
        public abstract boolean raffle();
        // 发放奖品
        public abstract  void dispensePrize();
    }
    
    // 不能抽奖的状态 NoRaffleState.java
    public class NoRaffleState extends State { 
    	 // 初始化时传入活动引用，扣除积分后改变其状态
        RaffleActivity activity;
    
        public NoRaffleState(RaffleActivity activity) { 
            this.activity = activity;
        }
    
        // 当前状态可以扣积分, 扣除后(假定扣除操作一定会成功),将状态设置成可以抽奖状态
        @Override
        public void deductMoney() { 
            System.out.println("扣除50积分成功，您可以抽奖了");
            activity.setState(activity.getCanRaffleState());
        }
    
        // 当前状态不能抽奖
        @Override
        public boolean raffle() { 
            System.out.println("扣了积分才能抽奖喔！");
            return false;
        }
    
        // 当前状态不能发奖品
        @Override
        public void dispensePrize() { 
            System.out.println("不能发放奖品");
        }
    }
    
    //可以抽奖的状态 CanRaffleState.java
    public class CanRaffleState extends State { 
        RaffleActivity activity;
    
        public CanRaffleState(RaffleActivity activity) { 
            this.activity = activity;
        }
    
        //已经扣除了积分，不能再扣
        @Override
        public void deductMoney() { 
            System.out.println("已经扣取过了积分");
        }
    
        //可以抽奖, 抽完奖后，根据实际情况，改成新的状态
        @Override
        public boolean raffle() { 
            System.out.println("正在抽奖，请稍等！");
            Random r = new Random();
            int num = r.nextInt(10);//随机生成一个0-9之间的数
            // 10%中奖机会
            if(num == 0){ 
                //中奖了：改变活动状态为发放奖品 context
                activity.setState(activity.getDispenseState());
                return true;
            }else{ 
                System.out.println("很遗憾没有抽中奖品！");
                // 未抽中：改变状态为不能抽奖
                activity.setState(activity.getNoRafflleState());
                return false;
            }
        }
    
        // 不能发放奖品
        @Override
        public void dispensePrize() { 
            System.out.println("没中奖，不能发放奖品");
        }
    }
    
    //发放奖品的状态 DispenseState.java
    public class DispenseState extends State { 
    	 // 初始化时传入活动引用，发放奖品后改变其状态
        RaffleActivity activity;
    
        public DispenseState(RaffleActivity activity) { 
            this.activity = activity;
        }
    
        @Override
        public void deductMoney() { 
            System.out.println("不能扣除积分");
        }
    
        @Override
        public boolean raffle() { 
            System.out.println("不能抽奖");
            return false;
        }
    
        //发放奖品
        @Override
        public void dispensePrize() { 
            if(activity.getCount() > 0){ 
                System.out.println("恭喜中奖了");
                // 改变状态为不能抽奖
                activity.setState(activity.getNoRafflleState());
            }else{ 
                System.out.println("很遗憾，奖品发送完了");
                // 改变状态为“奖品领完”, 后面我们就不可以抽奖
                activity.setState(activity.getDispensOutState());
                //System.out.println("抽奖活动结束");
                //System.exit(0);
            }
        }
    }
    
    /** * 奖品发放完毕的状态 * 说明，当我们activity 改变成 DispenseOutState， 抽奖活动结束，所有的活动都不能再进行 * DispenseOutState.java */
    public class DispenseOutState extends State { 
        RaffleActivity activity;// 初始化时传入活动引用
    
        public DispenseOutState(RaffleActivity activity) { 
            this.activity = activity;
        }
        @Override
        public void deductMoney() { 
            System.out.println("奖品发送完了，请下次再参加");
        }
    
        @Override
        public boolean raffle() { 
            System.out.println("奖品发送完了，请下次再参加");
            return false;
        }
    
        @Override
        public void dispensePrize() { 
            System.out.println("奖品发送完了，请下次再参加");
        }
    }
    
    // 抽奖活动 RaffleActivity.java
    public class RaffleActivity { 
        State state = null;//state 表示活动当前的状态，该状态是变化的
        int count = 0;    // 奖品数量
        
        // 四个属性，表示四种状态
        State noRafflleState = new NoRaffleState(this);
        State canRaffleState = new CanRaffleState(this);
        
        State dispenseState =  new DispenseState(this);
        State dispensOutState = new DispenseOutState(this);
    
        //构造器
        //1. 初始化当前的状态为 noRafflleState（即不能抽奖的状态）
        //2. 初始化奖品的数量 
        public RaffleActivity( int count) { 
            this.state = getNoRafflleState();
            this.count = count;
        }
    
        //扣积分, 调用当前状态的 deductMoney
        public void debuctMoney(){ 
            state.deductMoney();
        }
    
        //抽奖 
        public void raffle(){ 
        	// 如果当前的状态是抽奖成功
            if(state.raffle()){ 
            	//领取奖品
                state.dispensePrize();
            }
        }
    
        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 getNoRafflleState() {  return noRafflleState; }
        public void setNoRafflleState(State noRafflleState) { 
            this.noRafflleState = noRafflleState;
        }
    
        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 getDispensOutState() {  return dispensOutState; }
        public void setDispensOutState(State dispensOutState) { 
            this.dispensOutState = dispensOutState;
        }
    }
    
    //状态模式测试类 ClientTest.java
    public class ClientTest { 
    	public static void main(String[] args) { 
    		// 创建活动对象，奖品有1个奖品
            RaffleActivity activity = new RaffleActivity(1);
    
            // 我们连续抽30次奖
            for (int i = 0; i < 30; i++) { 
                System.out.println("------第" + (i + 1) + "次抽奖--------");
                // 参加抽奖，第一步点击扣除积分
                activity.debuctMoney();
                // 第二步抽奖
                activity.raffle();
            }
    	}
    }

## 四、注意事项和细节 ##

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70]: /images/20220829/d8f2e26c1dd940c0b39902261debc99c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5q2i5q2l5YmN6KGM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20220829/2c161a38b3bb476784a5cd8e1d776650.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5q2i5q2l5YmN6KGM_size_18_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20220829/a641a9099f5a4b93b834945782c8ecb0.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5q2i5q2l5YmN6KGM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: /images/20220829/374cd710a4a148f1a3b68e2639587450.png