定义

状态模式允许对象在内部状态改变时改变它的行为, 对象看起来好像修改了它的类

  • 这个模式将状态封装成独立的类, 并将动作委托到当前代表的对象
  • 当状态流转是固定的时候, 就适合放在context中; 当转换是更动态的时候, 通常放在状态类中

案例

背景
image.png
原来设计代码: 现在要增加一个状态, 这个类就需要大面积的更改, 不易拓展

  1. /**
  2.  * Machine
  3.  *
  4.  * @author xinzhang
  5.  * @author Shenzhen Greatonce Co Ltd
  6.  * @version 2020/1/22
  7.  * 投入硬币-->转动曲柄-->分发糖果
  8.  */
  9. public class GumballMachine {
  11.   // 糖果机有四种状态, 有无硬币, 有硬币, 无糖果, 有糖果
  12.   private final int NO_COIN = 0;
  13.   private final int HAS_COIN = 1;
  14.   private final int NO_GUMBALL = 2;
  15.   private final int HAS_GUMBALL = 3;
  17.   private int state = NO_GUMBALL;
  18.   private int gumballNum;
  20.   public GumballMachine(int gumballNum) {
  21.     this.gumballNum = gumballNum;
  22.     if (gumballNum > 0) {
  23.       state = NO_COIN;
  24.     }
  25.   }
  27.   /**
  28.    * 投入硬币
  29.    */
  30.   public void insertCoin() {
  31.     switch (state) {
  32.       case NO_COIN:
  33.       case HAS_GUMBALL:
  34.         System.out.println("有硬币了!请转动曲柄!");
  35.         state = HAS_COIN;
  36.         break;
  37.       case HAS_COIN:
  38.         System.out.println("有硬币了别再投了!");
  39.         break;
  40.       case NO_GUMBALL:
  41.         System.out.println("投也没用, 糖果售罄!");
  42.         break;
  43.     }
  44.   }
  46.   /**
  47.    * 退回硬币
  48.    */
  49.   public void ejectCoin() {
  50.     switch (state) {
  51.       case NO_COIN:
  52.         System.out.println("请先投入硬币!");
  53.         break;
  54.       case NO_GUMBALL:
  55.         System.out.println("糖没了, 硬币也是不会退的!");
  56.         break;
  57.       case HAS_GUMBALL:
  58.         System.out.println("已经转动了曲柄, 不给退!");
  59.         break;
  60.       case HAS_COIN:
  61.         System.out.println("退回硬币!");
  62.         state = NO_COIN;
  63.         break;
  64.     }
  65.   }
  67.   /**
  68.    * 转动曲柄
  69.    */
  70.   public void turnCrack() {
  71.     switch (state) {
  72.       case NO_COIN:
  73.         System.out.println("先投硬币才能转!");
  74.         break;
  75.       case HAS_COIN:
  76.         if (gumballNum > 0) {
  77.           state = HAS_GUMBALL;
  78.         } else {
  79.           state = NO_GUMBALL;
  80.         }
  81.         break;
  82.       case HAS_GUMBALL:
  83.         System.out.println("转过一次不能再转了!");
  84.         break;
  85.       case NO_GUMBALL:
  86.         System.out.println("没糖, 转也没用!");
  87.         break;
  88.     }
  89.   }
  91.   /**
  92.    * 发放糖果
  93.    */
  94.   public void dispense() {
  95.     switch (state) {
  96.       case NO_COIN:
  97.         System.out.println("先付钱!");
  98.         break;
  99.       case HAS_COIN:
  100.         System.out.println("先转曲柄!");
  101.         break;
  102.       case NO_GUMBALL:
  103.         System.out.println("没有糖果了!");
  104.         break;
  105.       case HAS_GUMBALL:
  106.         gumballNum--;
  107.         if (gumballNum <= 0) {
  108.           System.out.println("现在没糖了!");
  109.           state = NO_GUMBALL;
  110.         } else {
  111.           System.out.println("发一个糖果!");
  112.           state = NO_COIN;
  113.         }
  114.     }
  115.   }
  116. }

使用状态模式后:
image.png

Machine, 持有四种状态类(注意多态写法),构造方法中初始化, 作为外部调用的入口, 去调用状态的动作

  1. public class Machine {
  3.   private State noCoinState;
  4.   private State hasCoinState;
  5.   private State noGumballState;
  6.   private State hasGumballState;
  7.   private State state = noGumballState;
  8.   private int count = 0;
  10.   public Machine(int count) {
  11.     noCoinState = new NoCoinState(this);
  12.     hasCoinState = new HasCoinState(this);
  13.     noGumballState = new NoGumballState(this);
  14.     hasGumballState = new HasGumballState(this);
  15.     this.count = count;
  16.     if (count > 0) {
  17.       state = noCoinState;
  18.     }
  19.   }
  21.   public void insertCoin() {
  22.     state.insertCoin();
  23.   }
  25.   public void ejectCoin() {
  26.     state.ejectCoin();
  27.   }
  29.   public void turnCrack() {
  30.     state.turnCrack();
  31.   }
  33.   public void dispense() {
  34.     state.dispense();
  35.   }
  37.   public void releaseGumball() {
  38.     System.out.println("释放一个糖果!");
  39.     if (count > 0) {
  40.       count--;
  41.     }
  42.   }
  45.   public State getNoCoinState() {
  46.     return noCoinState;
  47.   }
  49.   public State getHasCoinState() {
  50.     return hasCoinState;
  51.   }
  53.   public State getNoGumballState() {
  54.     return noGumballState;
  55.   }
  57.   public State getHasGumballState() {
  58.     return hasGumballState;
  59.   }
  61.   public void setHasCoinState(State hasCoinState) {
  62.     this.hasCoinState = hasCoinState;
  63.   }
  65.   public void setNoGumballState(State noGumballState) {
  66.     this.noGumballState = noGumballState;
  67.   }
  69.   public void setHasGumballState(State hasGumballState) {
  70.     this.hasGumballState = hasGumballState;
  71.   }
  73.   public void setNoCoinState(State noCoinState) {
  74.     this.noCoinState = noCoinState;
  75.   }
  77.   public State getState() {
  78.     return state;
  79.   }
  81.   public void setState(State state) {
  82.     this.state = state;
  83.   }
  85.   public int getCount() {
  86.     return count;
  87.   }
  89.   public void setCount(int count) {
  90.     this.count = count;
  91.   }
  92. }

State接口

  1. public interface State {
  3.   void insertCoin();
  5.   void ejectCoin();
  7.   void turnCrack();
  9.   void dispense();
  10. }

NoCoinState, 持有machine对象, 在投币动作中, 改变machine的状态

  1. public class NoCoinState implements State {
  3.   Machine machine;
  5.   public NoCoinState(Machine machine) {
  6.     this.machine = machine;
  7.   }
  9.   @Override
  10.   public void insertCoin() {
  11.     System.out.println("有硬币了, 请转动曲柄!");
  12.     machine.setState(machine.getHasCoinState());
  13.   }
  15.   @Override
  16.   public void ejectCoin() {
  17.     System.out.println("没有硬币, 无法退!");
  18.   }
  20.   @Override
  21.   public void turnCrack() {
  22.     System.out.println("没有硬币, 不能转曲柄!");
  23.   }
  25.   @Override
  26.   public void dispense() {
  27.     System.out.println("请投币!");
  28.   }
  29. }

HasCoinState, 在转动曲柄动作中改变machine的状态

  1. public class HasCoinState implements State {
  3.   Machine machine;
  5.   public HasCoinState(Machine machine) {
  6.     this.machine = machine;
  7.   }
  9.   @Override
  10.   public void insertCoin() {
  11.     System.out.println("已经有硬币了, 别投了!");
  12.   }
  14.   @Override
  15.   public void ejectCoin() {
  16.     System.out.println("退出硬币!");
  17.     machine.setState(machine.getNoCoinState());
  18.   }
  20.   @Override
  21.   public void turnCrack() {
  22.     System.out.println("转动曲柄!");
  23.     machine.setState(machine.getHasGumballState());
  24.   }
  26.   @Override
  27.   public void dispense() {
  28.     System.out.println("请转曲柄!");
  29.   }
  30. }

HasGumballState, 在发糖动作中调用machine的方法, 并获取糖果数量来改变machine的状态

  1. public class HasGumballState implements State {
  3.   Machine machine;
  5.   public HasGumballState(Machine machine) {
  6.     this.machine = machine;
  7.   }
  9.   @Override
  10.   public void insertCoin() {
  11.     System.out.println("再投没用!");
  12.   }
  14.   @Override
  15.   public void ejectCoin() {
  16.     System.out.println("已转曲柄!不能退!");
  17.   }
  19.   @Override
  20.   public void turnCrack() {
  21.     System.out.println("已转了一次!请稍等!");
  22.   }
  24.   @Override
  25.   public void dispense() {
  26.     machine.releaseGumball();
  27.     if (machine.getCount() > 0) {
  28.       System.out.println("发糖!");
  29.       machine.setState(machine.getNoCoinState());
  30.     } else {
  31.       System.out.println("没糖了!");
  32.       machine.setState(machine.getNoGumballState());
  33.     }
  34.   }
  35. }

NoGumballState

  1. public class NoGumballState implements State {
  3.   Machine machine;
  5.   public NoGumballState(Machine machine) {
  6.     this.machine = machine;
  7.   }
  9.   @Override
  10.   public void insertCoin() {
  11.     System.out.println("没有糖果了, 投币也没用!");
  12.   }
  14.   @Override
  15.   public void ejectCoin() {
  16.     System.out.println("无法退币!");
  17.   }
  19.   @Override
  20.   public void turnCrack() {
  21.     System.out.println("没有糖果了, 转也没有用!");
  22.   }
  24.   @Override
  25.   public void dispense() {
  26.     System.out.println("发放失败!没有糖果了!");
  27.   }
  28. }

这样设计的好处:
1.让每个状态的行为局部化到他自己的类中;
2.对修改关闭, 对拓展开放;
3.更易阅读和理解
image.png