状态模式一般用来实现状态机，而状态机常用在游戏、工作流引擎等系统开发中。

什么是有限状态机？

有限状态机，英文翻译是 Finite State Machine，缩写为 FSM，简称为状态机。状态机有 3 个组成部分：

  • 状态（State）
  • 事件（Event）也称为转移条件（Transition Condition）。事件触发状态的转移及动作的执行。不过，动作不是必须的，也可能只转移状态，不执行任何动作。
  • 动作（Action）

形象的例子:

“超级马里奥”游戏不知道你玩过没有？在游戏中，马里奥可以变身为多种形态，比如小马里奥（Small Mario）、超级马里奥（Super Mario）、火焰马里奥（Fire Mario）、斗篷马里奥（Cape Mario）等等。在不同的游戏情节下，各个形态会互相转化，并相应的增减积分。比如，初始形态是小马里奥，吃了蘑菇之后就会变成超级马里奥，并且增加 100 积分。

其中，马里奥的不同形态就是状态机中的“状态”，游戏情节（比如吃了蘑菇）就是状态机中的“事件”，加减积分就是状态机中的“动作”。

image.png

  1. public enum State {
  2.   SMALL(0),
  3.   SUPER(1),
  4.   FIRE(2),
  5.   CAPE(3);
  7.   private int value;
  9.   private State(int value) {
  10.     this.value = value;
  11.   }
  13.   public int getValue() {
  14.     return this.value;
  15.   }
  16. }
  18. public class MarioStateMachine {
  19.   private int score;
  20.   private State currentState;
  22.   public MarioStateMachine() {
  23.     this.score = 0;
  24.     this.currentState = State.SMALL;
  25.   }
  26.   // 各种事件
  27.   public void obtainMushRoom() {
  28.     //TODO
  29.   }
  31.   public void obtainCape() {
  32.     //TODO
  33.   }
  35.   public void obtainFireFlower() {
  36.     //TODO
  37.   }
  39.   public void meetMonster() {
  40.     //TODO
  41.   }
  43.   public int getScore() {
  44.     return this.score;
  45.   }
  47.   public State getCurrentState() {
  48.     return this.currentState;
  49.   }
  50. }
  52. public class ApplicationDemo {
  53.   public static void main(String[] args) {
  54.     MarioStateMachine mario = new MarioStateMachine();
  55.     mario.obtainMushRoom(); // 触发事件
  56.     int score = mario.getScore();
  57.     State state = mario.getCurrentState();
  58.     System.out.println("mario score: " + score + "; state: " + state);
  59.   }
  60. }

状态机实现方式一：分支逻辑法

  1. 判断当前状态 (产生分支)
  2. 切换状态
  2. public class MarioStateMachine {
  3.   private int score;
  4.   private State currentState;
  6.   public MarioStateMachine() {
  7.     this.score = 0;
  8.     this.currentState = State.SMALL;
  9.   }
  11.   public void obtainMushRoom() {
  12.     if (currentState.equals(State.SMALL)) {
  13.       this.currentState = State.SUPER;
  14.       this.score += 100;
  15.     }
  16.   }
  18.   public void obtainCape() {
  19.     if (currentState.equals(State.SMALL) || currentState.equals(State.SUPER) ) {
  20.       this.currentState = State.CAPE;
  21.       this.score += 200;
  22.     }
  23.   }
  25.   public void obtainFireFlower() {
  26.     if (currentState.equals(State.SMALL) || currentState.equals(State.SUPER) ) {
  27.       this.currentState = State.FIRE;
  28.       this.score += 300;
  29.     }
  30.   }
  32.   public void meetMonster() {
  33.     if (currentState.equals(State.SUPER)) {
  34.       this.currentState = State.SMALL;
  35.       this.score -= 100;
  36.       return;
  37.     }
  39.     if (currentState.equals(State.CAPE)) {
  40.       this.currentState = State.SMALL;
  41.       this.score -= 200;
  42.       return;
  43.     }
  45.     if (currentState.equals(State.FIRE)) {
  46.       this.currentState = State.SMALL;
  47.       this.score -= 300;
  48.       return;
  49.     }
  50.   }
  52.   public int getScore() {
  53.     return this.score;
  54.   }
  56.   public State getCurrentState() {
  57.     return this.currentState;
  58.   }
  59. }

状态机实现方式二：查表法

image.png

  2. public enum Event {
  3.   GOT_MUSHROOM(0),
  4.   GOT_CAPE(1),
  5.   GOT_FIRE(2),
  6.   MET_MONSTER(3);
  8.   private int value;
  10.   private Event(int value) {
  11.     this.value = value;
  12.   }
  14.   public int getValue() {
  15.     return this.value;
  16.   }
  17. }
  19. public class MarioStateMachine {
  20.   private int score;
  21.   private State currentState;
  23.   private static final State[][] transitionTable = {
  24.           {SUPER, CAPE, FIRE, SMALL},
  25.           {SUPER, CAPE, FIRE, SMALL},
  26.           {CAPE, CAPE, CAPE, SMALL},
  27.           {FIRE, FIRE, FIRE, SMALL}
  28.   };
  30.   private static final int[][] actionTable = {
  31.           {+100, +200, +300, +0},
  32.           {+0, +200, +300, -100},
  33.           {+0, +0, +0, -200},
  34.           {+0, +0, +0, -300}
  35.   };
  37.   public MarioStateMachine() {
  38.     this.score = 0;
  39.     this.currentState = State.SMALL;
  40.   }
  42.   public void obtainMushRoom() {
  43.     executeEvent(Event.GOT_MUSHROOM);
  44.   }
  46.   public void obtainCape() {
  47.     executeEvent(Event.GOT_CAPE);
  48.   }
  50.   public void obtainFireFlower() {
  51.     executeEvent(Event.GOT_FIRE);
  52.   }
  54.   public void meetMonster() {
  55.     executeEvent(Event.MET_MONSTER);
  56.   }
  58.   private void executeEvent(Event event) {
  59.     int stateValue = currentState.getValue();
  60.     int eventValue = event.getValue();
  61.     this.currentState = transitionTable[stateValue][eventValue];
  62.     this.score = actionTable[stateValue][eventValue]; // +=?
  63.   }
  65.   public int getScore() {
  66.     return this.score;
  67.   }
  69.   public State getCurrentState() {
  70.     return this.currentState;
  71.   }
  73. }

状态机实现方式三：状态模式

MarioStateMachine 和各个状态类之间是双向依赖关系。MarioStateMachine 依赖各个状态类是理所当然的，但是，反过来，各个状态类为什么要依赖 MarioStateMachine 呢？这是因为，各个状态类需要更新 MarioStateMachine 中的两个变量，score 和 currentState。

  2. public interface IMario { //所有状态类的接口
  3.   State getName();
  4.   //以下是定义的事件
  5.   void obtainMushRoom();
  6.   void obtainCape();
  7.   void obtainFireFlower();
  8.   void meetMonster();
  9. }
  11. public class SmallMario implements IMario {
  12.   private MarioStateMachine stateMachine;
  14.   public SmallMario(MarioStateMachine stateMachine) {
  15.     this.stateMachine = stateMachine;
  16.   }
  18.   @Override
  19.   public State getName() {
  20.     return State.SMALL;
  21.   }
  23.   @Override
  24.   public void obtainMushRoom() {
  25.     stateMachine.setCurrentState(new SuperMario(stateMachine));
  26.     stateMachine.setScore(stateMachine.getScore() + 100);
  27.   }
  29.   @Override
  30.   public void obtainCape() {
  31.     stateMachine.setCurrentState(new CapeMario(stateMachine));
  32.     stateMachine.setScore(stateMachine.getScore() + 200);
  33.   }
  35.   @Override
  36.   public void obtainFireFlower() {
  37.     stateMachine.setCurrentState(new FireMario(stateMachine));
  38.     stateMachine.setScore(stateMachine.getScore() + 300);
  39.   }
  41.   @Override
  42.   public void meetMonster() {
  43.     // do nothing...
  44.   }
  45. }
  47. public class SuperMario implements IMario {
  48.   private MarioStateMachine stateMachine;
  50.   public SuperMario(MarioStateMachine stateMachine) {
  51.     this.stateMachine = stateMachine;
  52.   }
  54.   @Override
  55.   public State getName() {
  56.     return State.SUPER;
  57.   }
  59.   @Override
  60.   public void obtainMushRoom() {
  61.     // do nothing...
  62.   }
  64.   @Override
  65.   public void obtainCape() {
  66.     stateMachine.setCurrentState(new CapeMario(stateMachine));
  67.     stateMachine.setScore(stateMachine.getScore() + 200);
  68.   }
  70.   @Override
  71.   public void obtainFireFlower() {
  72.     stateMachine.setCurrentState(new FireMario(stateMachine));
  73.     stateMachine.setScore(stateMachine.getScore() + 300);
  74.   }
  76.   @Override
  77.   public void meetMonster() {
  78.     stateMachine.setCurrentState(new SmallMario(stateMachine));
  79.     stateMachine.setScore(stateMachine.getScore() - 100);
  80.   }
  81. }
  83. // 省略CapeMario、FireMario类...
  85. public class MarioStateMachine {
  86.   private int score;
  87.   private IMario currentState; // 不再使用枚举来表示状态
  89.   public MarioStateMachine() {
  90.     this.score = 0;
  91.     this.currentState = new SmallMario(this);
  92.   }
  94.   public void obtainMushRoom() {
  95.     this.currentState.obtainMushRoom();
  96.   }
  98.   public void obtainCape() {
  99.     this.currentState.obtainCape();
  100.   }
  102.   public void obtainFireFlower() {
  103.     this.currentState.obtainFireFlower();
  104.   }
  106.   public void meetMonster() {
  107.     this.currentState.meetMonster();
  108.   }
  110.   public int getScore() {
  111.     return this.score;
  112.   }
  114.   public State getCurrentState() {
  115.     return this.currentState.getName();
  116.   }
  118.   public void setScore(int score) {
  119.     this.score = score;
  120.   }
  122.   public void setCurrentState(IMario currentState) {
  123.     this.currentState = currentState;
  124.   }
  125. }