一个对象的行为取决于一个或者多个状态的属性变化，这样的属性称为状态，这个对象称为有状态的对象，对象的状态一般都是事先定义好的一些列值中取出。当这样的对象因为外部的互动而产生状态的变化，对象内部系统会随之产生对应的变化。不过状态模式在常见的软件开发中并不常用，状态模式一般用来实现状态机，所以常见应用于游戏或者工作流引擎中。
定义
状态模式（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就可以在不修改代码的情况下，添加新状态的马里奥，对于复杂状态的情况，维护和理解代码都会友好很多。
通过上面的例子，我们可以看到状态模式的优缺点。
优点
- 封装了转换规则。
- 枚举可能的状态，在枚举状态之前需要确定状态种类。
- 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
- 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
- 可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。
缺点
- 状态模式的使用必然会增加系统类和对象的个数。
- 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
- 状态模式对“开闭原则”的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态；而且修改某个状态类的行为也需修改对应类的源代码。
总结
状态模式的应用如开头所说，主要还是应用于游戏或者工作引擎流之类的场景，对于一些已知状态不会太多，同时也不会变化太多的情况，比如第一个例子，交通灯就只有三种颜色的变换，这种情况如果强行使用状态模式反而会使得代码和类增多，就没有必要必须使用状态模式。
