设计模式之美 - 64状态模式

状态模式一般用来实现状态机，主要应用在游戏、工作流引擎中。

状态机实现方式：分支逻辑法、查表法、状态模式

什么是有限状态机？

状态机有 3 个组成部分：状态（State）、事件（Event）、动作（Action），事件触发状态的转移及动作的执行，而“动作的执行”不是必须的。

图：有限状态机三个组成部分

图中“动作”用了虚线灰色，表示不是必须的

图：事件引起状态变化

图中忽略了“动作”，其实状态之间的连线可以对应地视作“动作”

案例：“超级马里奥”游戏

游戏中，马里奥可以变身为多种形态 ：小马里奥（Small Mario）、超级马里奥（Super Mario）、火焰马里奥（Fire Mario）
发生不同的事件时，形态会进行转化，且增加或减少积分，具体规则如下图

分支逻辑法实现状态机

分支逻辑法其实就是if else硬编码 ，事件对应类的方法，状态对应状态机类的状态属性，动作对应相应的操作。

在马里奥这个案例里我们定义一个状态机 MarioStateMachine 类 ，类中定义一个属性 state 表示状态（小、超级、火焰），定义score属性表示动作（加减积分）操作的结果。

class MarioStateMachine{
	private String state;
	private int score;
	public MarioStateMachine(){
		state = "small";
		score = 0;
	}
	/**
	 * 获取蘑菇
	 */
	public void obtainMushRoom(){
		state = "super";
		score +=100;
	}
	/**
	 * 获取火焰
	 */
	public void obtainFire(){
		state = "fire";
		score +=200;
	}
	/**
	 * 获取火焰
	 */
	public void meetMonster(){
		if("super".equals(state)){
			score -=100;
		}else if("fire".equals(state)){
			score -=200;
		}
		state = "small";
	}
}

从上面的代码中我们能总结出：

1、状态机类中的方法对应事件

2、状态通过状态机类的属性进行定义，事件方法中的部分操作进行状态转换

3、方法中的部分操作对应动作，动作的结果可以提现在类的属性上

上面的代码我们可以进一步优化一下，采用enum 类型来表示状态

public enum State {
    SMALL(0), SUPER(1), FIRE(2);
    private int value;
    private State(int value) {
        this.value = value;
    }
    public int getValue() {
        return this.value;
    }
}
class MarioStateMachine{
	private State currentState;
	private int score;
	public MarioStateMachine(){
		currentState= State.SMALL;
		score = 0;
	}
	/**
	 * 获取蘑菇
	 */
	public void obtainMushRoom(){
		currentState= State.SUPER;
		score +=100;
	}
	......
}

查表法实现状态机

自行查看原文…

状态模式实现状态机

状态模式通过将事件触发的状态转移和动作执行，拆分到不同的状态类中，来避免分支判断逻辑。

基于“分支逻辑法”的总结 和状态模式的定义，我们来尝试一下状态模式实现思路：

1、状态机类中的方法对应事件

2、状态通过状态机类的属性进行定义，这个属性类型是“状态类”， 事件方法中的部分操作进行状态转换，即将改变状态类

3、方法中的部分操作对应动作，动作的结果可以提现在类的属性上

为了 MarioStateMachine 类持有不同的“状态类”，我们抽象出一个“状态类”的接口

public interface IMario { //所有状态类的接口
    String getName();
    //以下是定义的事件
    default void obtainMushRoom(){};
    default void obtainCape(){};
    default void obtainFireFlower(){};
    void meetMonster();
}

从这个实现看，我们将事件方法同样定义在了“状态类”接口中。

public class MarioStateMachine implements IMario{
    private int score;
    private IMario currentState; // 不再使用枚举来表示状态

    public MarioStateMachine() {
        this.score = 0;
        this.currentState = new SmallMario(this);
    }
    public String getName(){
        return currentState.getName();
    }

    public void obtainMushRoom() {
        this.currentState.obtainMushRoom();
    }
	......
}
public class SmallMario implements IMario {
    private MarioStateMachine stateMachine;

    public SmallMario(MarioStateMachine stateMachine) {
        this.stateMachine = stateMachine;
    }

    @Override
    public String getName() {
        return "SmallMario";
    }

    @Override
    public void obtainMushRoom() {
        stateMachine.setCurrentState(new SuperMario(stateMachine));
        stateMachine.setScore(stateMachine.getScore() + 100);
    }

    @Override
    public void obtainFire() {
        stateMachine.setCurrentState(new FireMario(stateMachine));
        stateMachine.setScore(stateMachine.getScore() + 200);
    }

    @Override
    public void meetMonster() {
        // do nothing...
    }
}

状态机的事件方法其实就是委托给了当前的状态类事件方法来实现的，具体的操作封装在了各个状态类中。

注意：
状态机和各个状态类之间相互持有引用：

1、状态机持有各个状态类的引用
状态机将事件方法委托给具体的状态类执行，所以需要持有状态类的引用

2、状态类持有状态机的引用
状态类需要改变状态机的状态，即改变所持有的具体状态类，所以需要持有状态机的引用