设计模式之状态模式（State Pattern）

青旅半醒 2023-07-18 04:51 2阅读 0赞

### 文章目录 ###

*   *  一、定义
     *  二、特点
     *   *  2.1、优点：
         *  2.2、缺点：
     *  三、角色和UML类图
     *   *  3.1、主要角色：
         *  3.2、UML类图
     *  四、示例
     *   *  4.1、代码：
         *   *  4.1.1、State：状态
             *  4.1.2、StateForNoRaffle：NoRaffle（不能抽奖状态）
             *  4.1.3、StateForCanRaffle：CanRaffle（可以抽奖）
             *  4.1.4、StateForDispense：Dispense（发放奖品）
             *  4.1.5、StateForDispenseOut：DispenseOut（奖品发放完了，请下次再参加）
             *  4.1.6、RaffleActivity：Context（环境）：抽奖活动
             *  4.1.7、Client

在软件开发过程中，应用程序中的有些对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。

当有状态的对象与外部事件产生互动时，其内部状态会发生改变，从而使得其行为也随之发生改变。如人的情绪有高兴的时候和伤心的时候，不同的情绪有不同的行为，当然外界也会影响其情绪变化。

对这种有状态的对象编程，传统的解决方案是：将这些所有可能发生的情况全都考虑到，然后使用 `if-else` 语句来做状态判断，再进行不同情况的处理。但当对象的状态很多时，程序会变得很复杂。而且增加新的状态要添加新的 `if-else` 语句，这违背了“开闭原则”，不利于程序的扩展。

以上问题如果采用 `状态模式` 就能很好地得到解决。状态模式的解决思想是：当控制一个对象状态转换的条件表达式过于复杂时，把相关“判断逻辑”提取出来，放到一系列的状态类当中，这样可以把原来复杂的逻辑判断简单化。

## 一、定义 ##

状态的定义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

## 二、特点 ##

状态模式是一种对象行为型模。

### 2.1、优点： ###

1.  状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。
2.  减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。
3.  有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。

### 2.2、缺点： ###

1.  状态模式的使用必然会增加系统的类与对象的个数。
2.  状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。

## 三、角色和UML类图 ##

状态模式把受环境改变的对象行为包装在不同的状态对象里，其意图是让一个对象在其内部状态改变的时候，其行为也随之改变。现在我们来分析其基本结构和实现方法。

### 3.1、主要角色： ###

1.  `Context` （环境）：也称为上下文，它定义了客户感兴趣的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。
2.  `State` （抽象状态）：定义一个接口，用以封装环境对象中的特定状态所对应的行为。
3.  `ConcreteState` （具体状态）：实现抽象状态所对应的行为。

### 3.2、UML类图 ###

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

## 四、示例 ##

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

1）假如每参加一次这个活动要先扣除用户50积分，再抽奖，中奖概率是10%；

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

3）活动有四个状态: 可以抽奖、不能抽奖、发放奖品 和 奖品领完；

### 4.1、代码： ###

定义4种状态：

/** 不能抽奖状态 */
    State noRafflleState = new StateForNoRaffle(this);
    /** 可以抽奖的状态*/
    State canRaffleState = new StateForCanRaffle(this);
    
    /** 发放奖品的状态 */
    State dispenseState = new StateForDispense(this);
    /** 奖品发放完毕，请下次再参加 */
    State dispensOutState = new StateForDispenseOut(this);

#### 4.1.1、State：状态 ####

/** * 状态 */
    public abstract class State { 
    
    	/** * 扣除积分 - 50 */
    	public abstract void deductScore();
    
    	/** * 是否抽中奖品 * * @return */
    	public abstract boolean raffle();
    
    	/** * 发放奖品 */
    	public abstract void dispensePrize();
    
    }

#### 4.1.2、StateForNoRaffle：NoRaffle（不能抽奖状态） ####

/** * NoRaffle（不能抽奖状态） */
    public class StateForNoRaffle extends State { 
    
    	// 初始化时传入活动引用，扣除积分后改变其状态
    	RaffleActivity activity;
    
    	public StateForNoRaffle(RaffleActivity activity) { 
    		this.activity = activity;
    	}
    
    	/** * 当前状态可以扣积分 , 扣除后，将状态设置成可以抽奖状态 */
    	@Override
    	public void deductScore() { 
    		System.out.println("扣除50积分成功，您可以抽奖了");
    		activity.setState(activity.getCanRaffleState());
    	}
    
    	/** * 当前状态不能抽奖 */
    	@Override
    	public boolean raffle() { 
    		System.out.println("扣了积分才能抽奖喔！");
    		return false;
    	}
    
    	/** * 当前状态不能发奖品 */
    	@Override
    	public void dispensePrize() { 
    		System.out.println("不能发放奖品");
    	}
    }

#### 4.1.3、StateForCanRaffle：CanRaffle（可以抽奖） ####

import java.util.Random;
    
    /** * CanRaffle（可以抽奖） * */
    public class StateForCanRaffle extends State { 
    
    	RaffleActivity activity;
    
    	public StateForCanRaffle(RaffleActivity activity) { 
    		this.activity = activity;
    	}
    
    	/** * 已经扣除了积分，不能再扣 */
    	@Override
    	public void deductScore() { 
    		System.out.println("已经扣取过了积分");
    	}
    
    	/** * 可以抽奖, 抽完奖后，根据实际情况，改成新的状态 */
    	@Override
    	public boolean raffle() { 
    		System.out.println("正在抽奖，请稍等！");
    		Random r = new Random();
    		int num = r.nextInt(10);
    		// 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("没中奖，不能发放奖品");
    	}
    }

#### 4.1.4、StateForDispense：Dispense（发放奖品） ####

/** * Dispense（发放奖品） */
    public class StateForDispense extends State { 
    
    	// 初始化时传入活动引用，发放奖品后改变其状态
    	RaffleActivity activity;
    
    	public StateForDispense(RaffleActivity activity) { 
    		this.activity = activity;
    	}
    
    	//
    
    	@Override
    	public void deductScore() { 
    		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("很遗憾，奖品发送完了");
    			
    			/** * 因为奖品数量为0，因此将活动状态改为，请下次再参加。 */
    			// 后面我们就不可以抽奖
    			activity.setState(activity.getDispensOutState());
    			// System.out.println("抽奖活动结束");
    			// System.exit(0);
    		}
    
    	}
    }

#### 4.1.5、StateForDispenseOut：DispenseOut（奖品发放完了，请下次再参加） ####

/** * DispenseOut（奖品发放完了，请下次再参加） * * <pre> * 说明，当我们activity 改变成 DispenseOutState， 抽奖活动结束 * * </pre> */
    public class StateForDispenseOut extends State { 
    
    	// 初始化时传入活动引用
    	RaffleActivity activity;
    
    	public StateForDispenseOut(RaffleActivity 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("奖品发送完了，请下次再参加");
    	}
    }

#### 4.1.6、RaffleActivity：Context（环境）：抽奖活动 ####

/** * Context（环境）：抽奖活动 */
    public class RaffleActivity { 
    
    	// state 表示活动当前的状态，是变化
    	State state = null;
    	// 奖品数量
    	int count = 0;
    
    	/** * 四个属性，表示四种状态 */
    	/** 不能抽奖状态 */
    	State noRafflleState = new StateForNoRaffle(this);
    	
    	/** 可以抽奖的状态*/
    	State canRaffleState = new StateForCanRaffle(this);
    
    	
    	/** 发放奖品的状态 */
    	State dispenseState = new StateForDispense(this);
    	
    	/** 奖品发放完毕，请下次再参加 */
    	State dispensOutState = new StateForDispenseOut(this);
    
    	/** * 构造器 */
    	// 1. 初始化当前的状态为 noRafflleState（即不能抽奖的状态）
    	// 2. 初始化奖品的数量
    	public RaffleActivity(int count) { 
    		this.state = getNoRafflleState();
    		this.count = count;
    	}
    
    	/** * 第1步，扣分, 调用当前状态的 deductMoney */
    	public void debuctMoney() { 
    		state.deductScore();
    	}
    
    	/** * 第2步，抽奖 */
    	public void raffle() { 
    		// 第3步，判断是否抽奖成功
    		if (state.raffle()) { 
    			// 第4步，领取奖品
    			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;
    	}
    }

#### 4.1.7、Client ####

/** * 状态模式的测试类 */
    public class Client { 
    
    	public static void main(String[] args) { 
    		// 创建活动对象，奖品有1个奖品
    		RaffleActivity activity = new RaffleActivity(1);
    
    		/** * 我们连续抽300次奖 */
    		for (int i = 0; i < 30; i++) { 
    			System.out.println("--------第" + (i + 1) + "次抽奖----------");
    
    			// 第1步，点击扣除积分
    			activity.debuctMoney();
    
    			// 第2步，抽奖
    			activity.raffle();
    		}
    	}
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9qaW4yMWNlbg_size_16_color_FFFFFF_t_70]: /images/20230528/8c52c15553974e4bb06d5cd3d7c37474.png