1. 意图（Intent）

允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它所属的类。

2. 类图（Class Diagram）

79df886f-fdc3-4020-a07f-c991bb58e0d8.png

3. 实现（Implementation）

I 商品存储案例

商品库存中心有个最基本的需求是减库存和补库存，我们看看怎么用状态模式来写。
核心在于，我们的关注点不再是 Context 是该进行哪种操作，而是关注在这个 Context 会有哪些操作。
定义状态接口：[ State ]

  1. public interface State {
  2.     public void doAction(Context context);
  3. }

[ ConcreteState ]
定义减库存的状态：

  1. public class DeductState implements State {
  3.     public void doAction(Context context) {
  4.         System.out.println("商品卖出，准备减库存");
  5.         context.setState(this);
  6.         //... 执行减库存的具体操作
  7.     }
  9.     public String toString() {
  10.         return "Deduct State";
  11.     }
  12. }

定义补库存状态：

  1. public class RevertState implements State {
  3.     public void doAction(Context context) {
  4.         System.out.println("给此商品补库存");
  5.         context.setState(this);
  6.         //... 执行加库存的具体操作
  7.     }
  9.     public String toString() {
  10.         return "Revert State";
  11.     }
  12. }

前面用到了 context.setState(this)，我们来看看怎么定义 Context 类：：[ Context ]

  1. public class Context {
  2.     private State state;
  3.     private String name;
  5.     public Context(String name) {
  6.         this.name = name;
  7.     }
  9.     public void setState(State state) {
  10.         this.state = state;
  11.     }
  13.     public void getState() {
  14.         return this.state;
  15.     }
  16. }

我们来看下客户端调用，大家就一清二楚了：

  1. public static void main(String[] args) {
  2.     // 我们需要操作的是 iPhone X
  3.     Context context = new Context("iPhone X");
  5.     // 看看怎么进行补库存操作
  6.     State revertState = new RevertState();
  7.     revertState.doAction(context);
  9.     // 同样的，减库存操作也非常简单
  10.     State deductState = new DeductState();
  11.     deductState.doAction(context);
  13.     // 如果需要我们可以获取当前的状态
  14.     // context.getState().toString();
  15. }

读者可能会发现，在上面这个例子中，如果我们不关心当前 context 处于什么状态，那么 Context 就可以不用维护 state 属性了，那样代码会简单很多。

不过，商品库存这个例子毕竟只是个例，我们还有很多实例是需要知道当前 context 处于什么状态的。

II 糖果销售机案例

糖果销售机有多种状态，每种状态下销售机有不同的行为，状态可以发生转移，使得销售机的行为也发生改变。
396be981-3f2c-4fd9-8101-dbf9c841504b.jpg
[ State ]

  1. public interface State {
  3.     // 投入 25 分钱
  4.     void insertQuarter();
  6.     // 退回 25 分钱
  7.     void ejectQuarter();
  9.     // 转动曲柄
  10.     void turnCrank();
  12.     // 发放糖果
  13.     void dispense();
  14. }

[ ConcreteState ]
有四分之一状态

  1. public class HasQuarterState implements State {
  3.     private GumballMachine gumballMachine;    // 口香糖机
  5.     public HasQuarterState(GumballMachine gumballMachine) {
  6.         this.gumballMachine = gumballMachine;
  7.     }
  9.     @Override
  10.     public void insertQuarter() {
  11.         System.out.println("You can't insert another quarter");
  12.     }
  14.     @Override
  15.     public void ejectQuarter() {
  16.         System.out.println("Quarter returned");
  17.         gumballMachine.setState(gumballMachine.getNoQuarterState());
  18.     }
  20.     @Override
  21.     public void turnCrank() {
  22.         System.out.println("You turned...");
  23.         gumballMachine.setState(gumballMachine.getSoldState());
  24.     }
  26.     @Override
  27.     public void dispense() {
  28.         System.out.println("No gumball dispensed");
  29.     }
  30. }

无四分之一状态

  1. public class NoQuarterState implements State {
  3.     GumballMachine gumballMachine;
  5.     public NoQuarterState(GumballMachine gumballMachine) {
  6.         this.gumballMachine = gumballMachine;
  7.     }
  9.     @Override
  10.     public void insertQuarter() {
  11.         System.out.println("You insert a quarter");
  12.         gumballMachine.setState(gumballMachine.getHasQuarterState());
  13.     }
  15.     @Override
  16.     public void ejectQuarter() {
  17.         System.out.println("You haven't insert a quarter");
  18.     }
  20.     @Override
  21.     public void turnCrank() {
  22.         System.out.println("You turned, but there's no quarter");
  23.     }
  25.     @Override
  26.     public void dispense() {
  27.         System.out.println("You need to pay first");
  28.     }
  29. }

售罄状态

  1. public class SoldOutState implements State {
  3.     GumballMachine gumballMachine;
  5.     public SoldOutState(GumballMachine gumballMachine) {
  6.         this.gumballMachine = gumballMachine;
  7.     }
  9.     @Override
  10.     public void insertQuarter() {
  11.         System.out.println("You can't insert a quarter, the machine is sold out");
  12.     }
  14.     @Override
  15.     public void ejectQuarter() {
  16.         System.out.println("You can't eject, you haven't inserted a quarter yet");
  17.     }
  19.     @Override
  20.     public void turnCrank() {
  21.         System.out.println("You turned, but there are no gumballs");
  22.     }
  24.     @Override
  25.     public void dispense() {
  26.         System.out.println("No gumball dispensed");
  27.     }
  28. }

售出状态

  1. public class SoldState implements State {
  3.     GumballMachine gumballMachine;
  5.     public SoldState(GumballMachine gumballMachine) {
  6.         this.gumballMachine = gumballMachine;
  7.     }
  9.     @Override
  10.     public void insertQuarter() {
  11.         System.out.println("Please wait, we're already giving you a gumball");
  12.     }
  14.     @Override
  15.     public void ejectQuarter() {
  16.         System.out.println("Sorry, you already turned the crank");
  17.     }
  19.     @Override
  20.     public void turnCrank() {
  21.         System.out.println("Turning twice doesn't get you another gumball!");
  22.     }
  24.     @Override
  25.     public void dispense() {
  26.         gumballMachine.releaseBall();
  27.         if (gumballMachine.getCount() > 0) {
  28.             gumballMachine.setState(gumballMachine.getNoQuarterState());
  29.         } else {
  30.             System.out.println("Oops, out of gumballs");
  31.             gumballMachine.setState(gumballMachine.getSoldOutState());
  32.         }
  33.     }
  34. }

[ Context ]

  1. public class GumballMachine {
  3.     private State soldOutState;
  4.     private State noQuarterState;
  5.     private State hasQuarterState;
  6.     private State soldState;
  8.     private State state;
  9.     private int count = 0;    // 标记口香糖个数,由构造函数的 numberGumballs 初始化
  11.     public GumballMachine(int numberGumballs) {
  12.         count = numberGumballs;
  13.         soldOutState = new SoldOutState(this);
  14.         noQuarterState = new NoQuarterState(this);
  15.         hasQuarterState = new HasQuarterState(this);
  16.         soldState = new SoldState(this);
  18.         if (numberGumballs > 0) {
  19.             state = noQuarterState;
  20.         } else {
  21.             state = soldOutState;
  22.         }
  23.     }
  25.     public void insertQuarter() {
  26.         state.insertQuarter();
  27.     }
  29.     public void ejectQuarter() {
  30.         state.ejectQuarter();
  31.     }
  33.     public void turnCrank() {
  34.         state.turnCrank();
  35.         state.dispense();
  36.     }
  38.     public void setState(State state) {
  39.         this.state = state;
  40.     }
  42.     public void releaseBall() {
  43.         System.out.println("A gumball comes rolling out the slot...");
  44.         if (count != 0) {
  45.             count -= 1;
  46.         }
  47.     }
  49.     public State getSoldOutState() {
  50.         return soldOutState;
  51.     }
  53.     public State getNoQuarterState() {
  54.         return noQuarterState;
  55.     }
  57.     public State getHasQuarterState() {
  58.         return hasQuarterState;
  59.     }
  61.     public State getSoldState() {
  62.         return soldState;
  63.     }
  65.     public int getCount() {
  66.         return count;
  67.     }
  68. }

客户端：

  1. public class Client {
  3.     public static void main(String[] args) {
  5.         GumballMachine gumballMachine = new GumballMachine(5);
  6.         # 1 
  7.         gumballMachine.insertQuarter();
  8.         gumballMachine.turnCrank();
  10.         # 2
  11.         gumballMachine.insertQuarter();
  12.         gumballMachine.ejectQuarter();
  13.         gumballMachine.turnCrank();
  15.         # 3
  16.         gumballMachine.insertQuarter();
  17.         gumballMachine.turnCrank();
  19.         # 4
  20.         gumballMachine.insertQuarter();
  21.         gumballMachine.turnCrank();
  22.         gumballMachine.ejectQuarter();
  24.         # 5
  25.         gumballMachine.insertQuarter();
  26.         gumballMachine.insertQuarter();
  27.         gumballMachine.turnCrank();
  29.         # 6
  30.         gumballMachine.insertQuarter();
  31.         gumballMachine.turnCrank();
  33.         # 7
  34.         gumballMachine.insertQuarter();
  35.         gumballMachine.turnCrank();
  36.     }
  37. }

输出：

  1. #1
  2. You insert a quarter
  3. You turned...
  4. A gumball comes rolling out the slot...
  6. #2
  7. You insert a quarter
  8. Quarter returned
  9. You turned, but there's no quarter
  10. You need to pay first
  12. #3
  13. You insert a quarter
  14. You turned...
  15. A gumball comes rolling out the slot...
  17. #4
  18. You insert a quarter
  19. You turned...
  20. A gumball comes rolling out the slot...
  21. You haven't insert a quarter
  23. #5
  24. You insert a quarter
  25. You can't insert another quarter
  26. You turned...
  27. A gumball comes rolling out the slot...
  29. #6
  30. You insert a quarter
  31. You turned...
  32. A gumball comes rolling out the slot...
  33. Oops, out of gumballs
  35. #7
  36. You can't insert a quarter, the machine is sold out
  37. You turned, but there are no gumballs
  38. No gumball dispensed