介绍

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

原理

image-20201016235321857.png
对原理类图的说明-即(状态模式的角色及职责)

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

案例

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

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

image-20201016235456558.pngimage-20201016235609024.png

  1. //state抽象类
  2. public abstract class State {
  3.     public abstract void deductMoney();    //抽奖前扣除积分
  4.     public abstract boolean raffle();    //抽奖
  5.     public abstract void dispensePrize();//发奖
  6. }
  8. //未抽奖状态
  9. public class NoRaffleState extends State{
  10.     private int integral;        //抽奖积分
  11.     private Activity activity;
  13.     public NoRaffleState(int integral, Activity activity) {
  14.         this.integral = integral;
  15.         this.activity = activity;
  16.     }
  18.     @Override
  19.     public void deductMoney() {
  20.         if (this.integral>50){
  21.             this.integral=this.integral-50;
  22.             activity.setState(activity.getCanRaffleState());
  23.             System.out.println("50积分已扣除");
  24.         }
  25.         else {
  26.             System.out.println("很抱歉积分不足,不能抽奖");
  27.         }
  28.     }
  30.     @Override
  31.     public boolean raffle() {
  32.         System.out.println("很抱歉,不能抽奖");
  33.         return false;
  34.     }
  36.     @Override
  37.     public void dispensePrize() {
  38.         System.out.println("很抱歉,不能发放奖品");
  39.     }
  40. }
  42. //可以抽奖状态
  43. public class CanRaffleState extends State{
  44.     private Activity activity;
  46.     public CanRaffleState(Activity activity) {
  47.         this.activity = activity;
  48.     }
  50.     @Override
  51.     public void deductMoney() {
  52.         System.out.println("很抱歉,不能扣积分");
  53.     }
  55.     @Override
  56.     public boolean raffle() {
  57.         System.out.println("开始抽奖----");
  58.         Random random = new Random();
  59.         int num = random.nextInt(10);    //随机在1-10之前产生随机数
  60.         if (num==0){
  61.             activity.setState(activity.getDispenseState());
  62.             return true;
  63.         }else {
  64.             System.out.println("很遗憾,没有中奖");
  65.             activity.setState(activity.getNoRaffleState());
  66.             return false;
  67.         }
  68.     }
  70.     @Override
  71.     public void dispensePrize() {
  72.         System.out.println("很抱歉,不能发奖");
  73.     }
  74. }
  76. //发奖状态
  77. public class DispenseState extends State{
  78.     private Activity activity;
  80.     public DispenseState(Activity activity) {
  81.         this.activity = activity;
  82.     }
  84.     @Override
  85.     public void deductMoney() {
  86.         System.out.println("很抱歉,不能扣除积分");
  87.     }
  89.     @Override
  90.     public boolean raffle() {
  91.         System.out.println("很抱歉,不能抽奖");
  92.         return false;
  93.     }
  95.     @Override
  96.     public void dispensePrize() {
  97.         if (activity.getPrizeCount()>0){
  98.             activity.setState(activity.getNoRaffleState());//领奖后会到未抽奖状态
  99.             System.out.println("恭喜你,请领取你的奖品");
  100.         }
  101.     }
  102. }
  1. //抽奖活动类
  2. public class Activity {
  3.     private State state;    //初始状态为空
  4.      int PrizeCount;        //奖品数量
  6.    private NoRaffleState noRaffleState = new NoRaffleState(50*1000,this);
  7.    private CanRaffleState canRaffleState = new CanRaffleState(this);
  8.    private DispenseState dispenseState =new DispenseState(this);
  12.     public Activity(int prizeCount) {
  13.         this.state = noRaffleState;            //构建Activity对象时初始化状态为未抽奖状态
  14.        this.PrizeCount = prizeCount;
  15.     }
  17.     public void debuctMoney(){
  18.         if (PrizeCount==0){            //判断奖品是否还有，没有则活动结束
  19.             System.out.println("奖品已发送完毕,抽奖活动结束");
  20.             System.exit(0);
  21.         }
  22.         state.deductMoney();
  23.     }
  25.     public void raffle(){        //抽奖
  26.         if(state.raffle()){        //如果中奖则发奖
  27.             state.dispensePrize();
  28.         }
  29.     }
  31.     public State getState() {
  32.         return state;
  33.     }
  35.     public void setState(State state) {
  36.         this.state = state;
  37.     }
  39.     public int getPrizeCount() {        //每次领完奖后奖品-1
  40.         int Count = PrizeCount;
  41.         PrizeCount--;
  42.         return Count;
  43.     }
  45.     public void setPrizeCount(int prizeCount) {
  46.         PrizeCount = prizeCount;
  47.     }
  49.     public NoRaffleState getNoRaffleState() {
  50.         return noRaffleState;
  51.     }
  53.     public void setNoRaffleState(NoRaffleState noRaffleState) {
  54.         this.noRaffleState = noRaffleState;
  55.     }
  57.     public CanRaffleState getCanRaffleState() {
  58.         return canRaffleState;
  59.     }
  61.     public void setCanRaffleState(CanRaffleState canRaffleState) {
  62.         this.canRaffleState = canRaffleState;
  63.     }
  65.     public DispenseState getDispenseState() {
  66.         return dispenseState;
  67.     }
  69.     public void setDispenseState(DispenseState dispenseState) {
  70.         this.dispenseState = dispenseState;
  71.     }
  72. }
  1. //测试
  2. public class Client {
  3.     public static void main(String[] args) {
  4.         Activity activity = new Activity(2);
  5.         for (int i = 0; i < 100; i++) {            //模拟100次抽奖
  6.             System.out.println("------第"+(i+1)+"次抽奖------");
  7.             activity.debuctMoney();
  8.             activity.raffle();
  9.         }
  10.     }
  11. }

image-20201017000659379.png

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

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

态要求有不同的行为的时候，可以考虑使用状态模式