设计模式：状态模式

一个对象的行为取决于一个或者多个状态的属性变化，这样的属性称为状态，这个对象称为有状态的对象，对象的状态一般都是事先定义好的一些列值中取出。当这样的对象因为外部的互动而产生状态的变化，对象内部系统会随之产生对应的变化。不过状态模式在常见的软件开发中并不常用，状态模式一般用来实现状态机，所以常见应用于游戏或者工作流引擎中。

定义

状态模式（state pattern）: 允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。其别名为状态对象(Objects for States)，状态模式是一种对象行为型模式。

结构

State 状态抽象类
定义一个接口，用以封装环境（Context）对象的一个特定的状态所对应的行为。
ConcreteState 具体状态类
每一个具体状态类都实现了环境（Context）的一个状态所对应的行为。
Context 环境类，或者StateManagement
定义客户端所感兴趣的接口，并且保留一个具体状态类的实例。这个具体状态类的实例给出此环境对象的现有状态。

特点

它是处理FSM 的，也就是finite state management。所以状态模式第一个条件就是状态要是有限的，不能太多。
状态的唯一性。下文提到的交通灯是一维的状态切换，马里奥是二位的状态切换。但是不管维数如何，在固定的条件下，状态总是固定的，而不是变化的。因此就可以用一个全局的context来维护状态，所有的状态子类都可以通过context 的状态来获得。
状态模式的特点就是通过context 进行了解耦，把判断逻辑交给了context。有统一的地方进行分配。

状态模式类图

实例

交通灯有红，黄，绿，而它们的状态就是亮和不亮，所以我们先定义一个State接口。

public interface LightState {

    void handle();
}

然后分别实现它的ConcreteState类

public class RedLight implements LightState{

    @Override
    public void handle() {

        System.out.println("Red !");
    }
}

public class YellowLight implements LightState{

    @Override
    public void handle() {
        System.out.println("Yellow !");
    }
}

public class GreenLight implements LightState{

    @Override
    public void handle() {
        System.out.println("Green !");
    }
}

状态类和状态实现类有了，现在需要定义Context来管理这些状态。

public class LightContext {

    private LightState lightState;

    public void setLightState(LightState lightState) {
        this.lightState = lightState;
    }

    public void request() {
        lightState.handle();
    }
}

到这里，状态模式的三大结构就已经定义好了，接下来就是试一下一个客户端，来定义交通灯状态的规则。

public class LightClient {

    public void start() throws InterruptedException {
        ArrayList<LightState> lights = new ArrayList<>();
        lights.add(new RedLight());
        lights.add(new YellowLight());
        lights.add(new GreenLight());

        LightContext context = new LightContext();
        int index = 0;
        while (true) {
            context.setLightState(lights.get(index));
            context.request();
            index ++;
            Thread.sleep(3000);
            if (index == 3) {
                index = 0;
            }
        }
    }
}

我们只要执行客户端LightClient的start方法，就可以启动的我们的交通灯。这里定义的规则非常的简单，先亮红灯，然后美三秒切换灯，红 => 黄 => 绿 => 红 => 黄=>......不停的切换。

Red !
Yellow !
Green !
Red !
Yellow !
Green !
Red !
Yellow !
Green !
Red !
Yellow !
Green !
Red !

这里只是一个状态非常简单的例子，直接这么看可能觉得本来一个类或者一个方法就能解决，创建了这么多的类，代码倒还变得复杂了，那么再来一个稍微复杂些的例子。

这里以我们熟悉的游戏，超级马里奥为例子，马里奥有小马里奥(Small Mario)、超级马里奥(Super Mario)、斗篷马里奥（Cape Mario）、火焰马里奥(fire Mario)，在不同的游戏情节下，各种形态相互转换，并且相应的增减积分。比如：初始形态是小马里奥，吃了蘑菇之后就会变成超级马里奥，并且增加100积分。实际上，马里奥形态的转变就是一个状态机。其中，马里奥的不同形态就是状态机中的不同"状态"，游戏情节(比如吃蘑菇)就是状态机中的“事件”，加减积分就是状态机中的“动作”。比如，吃蘑菇这个"事件"，会触发状态转移：从小马里奥变身为超级马里奥，以及触发“动作”的执行（增加100积分）。在这个例子中可以简化为下图的状态：

马里奥状态图

如果根据直觉和逻辑，我们用if-else创建状态机，那么代码会类似如下：

public class MairoStateMachine {
    private int score;
    private MarioState currentState;

    public MairoStateMachine() {
        this.score=0;
        currentState=MarioState.SMALL;
    }

    //吃了蘑菇
    public void getMushroom(){
        if(currentState.equals(MarioState.SMALL)){
            this.currentState = MarioState.SUPPER;
            score+=100;
        }
    }

    //获得斗篷
    public void getCape(){
        if(currentState.equals(MarioState.SMALL) || currentState.equals(MarioState.SUPPER)){
            this.currentState = MarioState.CAPE;
            score+=200;
        }
    }

    //获得火焰
    public void getFireFlower(){
        if(currentState.equals(MarioState.SMALL) || currentState.equals(MarioState.SUPPER)){
            this.currentState = MarioState.FIRE;
            score+=300;
        }
    }

    //碰到小怪物
    public void touchMonster(){
        if(currentState.equals(MarioState.SUPPER)){
            this.currentState = MarioState.SMALL;
            score-=100;
        }else if(currentState.equals(MarioState.CAPE)){
            this.currentState = MarioState.SMALL;
            score-=200;
        }else if(currentState.equals(MarioState.FIRE)){
            this.currentState = MarioState.SMALL;
            score-=300;
        }
    }

    public int getScore() {
        return score;
    }

    public MarioState getCurrentState() {
        return currentState;
    }
}

这样的代码，状态机会随着状态的增加，要写大量的if-else的代码，而之前的逻辑也有可能要进行改动，这样对于维护和阅读都是一个很大的麻烦。所以下面我们用状态模式来实现。

创建一个State接口

public interface IMarioState {
    String getName();

    void getMushroom();

    void getCape();

    void getFireFlower();

    void touchMonster();
}

创建Context，或者说状态机

public class MarioContext {
    private int score;
    private IMarioState currentState;

    public MarioContext() {
        this.score = 0;
        this.currentState = new SmallMario(this);
    }

    public void getMushroom() {
        this.currentState.getMushroom();
    }

    public void getCape() {
        this.currentState.getCape();
    }

    public void getFireFlower() {
        this.currentState.getFireFlower();
    }

    public void touchMonster() {
        this.currentState.touchMonster();
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public IMarioState getCurrentState() {
        return currentState;
    }

    public void setCurrentState(IMarioState currentState) {
        this.currentState = currentState;
    }
}

接下来实现各个状态的马里奥

初始化的小马里奥

public class SmallMario implements IMarioState{

    private MarioContext context;

    public SmallMario(MarioContext marioContext) {
        this.context = marioContext;
    }

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

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

    @Override
    public void getCape() {
        context.setCurrentState(new CapeMario(context));
        context.setScore(context.getScore() + 200);
    }

    @Override
    public void getFireFlower() {
        context.setCurrentState(new FireMario(context));
        context.setScore(context.getScore() + 300);
    }

    @Override
    public void touchMonster() {
        System.out.println("game over !");
        System.exit(0);
    }
}

正常状态的大马里奥

public class SuperMario implements IMarioState {

    private MarioContext context;

    public SuperMario(MarioContext context) {
        this.context = context;
    }

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

    @Override
    public void getMushroom() {
        //do nothing
    }

    @Override
    public void getCape() {
        context.setCurrentState(new CapeMario(context));
        context.setScore(context.getScore() + 200);
    }

    @Override
    public void getFireFlower() {
        context.setCurrentState(new FireMario(context));
        context.setScore(context.getScore() + 300);
    }

    @Override
    public void touchMonster() {
        context.setCurrentState(new SmallMario(context));
        context.setScore(context.getScore() - 100);
    }
}

会射击的斗篷马里奥

public class CapeMario implements IMarioState {

    private final MarioContext context;

    public CapeMario(MarioContext context) {
        this.context = context;
    }

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

    @Override
    public void getMushroom() {
        //do nothing
    }

    @Override
    public void getCape() {
        //do nothing
    }

    @Override
    public void getFireFlower() {
        //do nothing
    }

    @Override
    public void touchMonster() {
        context.setCurrentState(new SmallMario(context));
        context.setScore(context.getScore() - 100);
    }
}

吃了星星的火焰马里奥

public class FireMario implements IMarioState {

    private final MarioContext context;

    public FireMario(MarioContext context) {
        this.context = context;
    }

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

    @Override
    public void getMushroom() {
        //do nothing
    }

    @Override
    public void getCape() {
        //do nothing
    }

    @Override
    public void getFireFlower() {
        //do nothing
    }

    @Override
    public void touchMonster() {
        context.setCurrentState(new SuperMario(context));
        context.setScore(context.getScore() - 100);
    }
}

启动马里奥的状态机

public class MarioClient {

    public void start() {
        MarioContext context = new MarioContext();
        context.getMushroom();
        context.getFireFlower();
    }
}

这样状态机MarioContext就可以在不修改代码的情况下，添加新状态的马里奥，对于复杂状态的情况，维护和理解代码都会友好很多。

通过上面的例子，我们可以看到状态模式的优缺点。

优点

封装了转换规则。
枚举可能的状态，在枚举状态之前需要确定状态种类。
将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

缺点

状态模式的使用必然会增加系统类和对象的个数。
状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
状态模式对“开闭原则”的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态；而且修改某个状态类的行为也需修改对应类的源代码。

总结

状态模式的应用如开头所说，主要还是应用于游戏或者工作引擎流之类的场景，对于一些已知状态不会太多，同时也不会变化太多的情况，比如第一个例子，交通灯就只有三种颜色的变换，这种情况如果强行使用状态模式反而会使得代码和类增多，就没有必要必须使用状态模式。

设计模式：状态模式

定义

结构

特点

实例

优点

缺点

总结

推荐阅读更多精彩内容