设计模式 - 状态模式(State)

State模式允许一个对象在其内部状态改变时改变它的行为。当一个

对象收到其他对象的请求时, 它根据自身的当前状态作出不同的反应。

• 一个对象的行为取决于它的状态, 并且它必须在运行时刻根据状态改变它的行为；同时对象的行为引起对象的状态的改变。

• 一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举常量表示。通常, 有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这使得你可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其他对象而独立变化。

通过 state模式去除复杂的状态改变条件语句。

类图：



案例：地铁闸机状态机

若状态机在lock状态收到一个coin事件，状态改变成unlocked状态并执行unlock动作；

若状态机在unlock状态再收到一个coin事件，状态不变显示”thank you”;

若状态机在unlock状态收到一个pass事件，状态改变成locked状态并执行lock动作；

若状态机在lock状态收到一个pass事件，状态不变并报警。



Step 1: 没有使用State模式，Turnstile对象负责接收事件，TurnstileController负责执行动作。

public class Turnstile {
//states
public static final int LOCKED   = 0;
public static final int UNLOCKED = 1;

private TurnstileController controller;
private int state = LOCKED;

public Turnstile(TurnstileController controller) {
this.controller = controller;
}
public void coin() { //coin event
if(state == LOCKED) {//状态改变条件语句
state = UNLOCKED;
unlock();
} else {
thankyou();
}
}
public void pass() { //pass event
if(state == UNLOCKED) {//状态改变条件语句
state = LOCKED;
lock();
} else {
alarm();
}
}
public void unlock() {
controller.unlock();
}
public void lock() {
controller.lock();
}
public void alarm() {
controller.alarm();
}
public void thankyou() {
controller.thankyou();
}
public boolean isLocked() {
return state == LOCKED;
}
public void setLocked() {
state = LOCKED;
}
public boolean isUnlocked() {
return state == UNLOCKED;
}
public void setUnlocked() {
state = UNLOCKED;
}
}

public class TurnstileController {
public void unlock() {
System.out.println("unlocked turnstile");
}
public void thankyou() {
System.out.println("thank you");
}
public void lock() {
System.out.println("Locked turnstile");
}
public void alarm () {
System.out.println("Can not pass as it is locked");
}
}

测试代码：

public class TurnstileTest {
@Test
public void testTurntileTest() {
TurnstileController controller = new TurnstileController();
Turnstile turntile = new Turnstile(controller);
assertTrue(turntile.isLocked());
turntile.coin();
assertTrue(turntile.isUnlocked());

turntile.coin();
assertTrue(turntile.isUnlocked());

turntile.pass();
assertTrue(turntile.isLocked());

turntile.pass();
assertTrue(turntile.isLocked());

}
}

Step 2： 使用State模式重构去除这些状态改变条件语句。

可以识别出coin()和pass()方法里有状态改变条件语句，定义一个State的接口或抽象超类，将这些方法复制到State的接口或抽象超类 （将上下文类Turnstile传入State中的方法，State的实现类可以调用上下文的方法）：

public interface TurnstileState {
public void coin(Turnstile turnstile);
public void pass(Turnstile turnstile);
}

定义实现TurnstileState接口的两个State类：

public class LockedTurntileState implements TurnstileState {
public void coin(Turnstile turnstile) { //coin event
turnstile.setUnlocked();
turnstile.unlock();
}
public void pass(Turnstile turnstile) { //pass event
turnstile.alarm();
}
}

public class UnlockedTurnstileState implements TurnstileState {
public void coin(Turnstile turnstile) {
turnstile.thankyou();
}
public void pass(Turnstile turnstile) {
turnstile.setLocked();
turnstile.lock();
}
}

Step 3: 重构Turnstile，Turnstile称为上下文(context)，上下文对象将状态相关的行为委托到状态对象上；上下文对象有一个初始的状态对象。

1) 将状态类型码换成 状态对象

2) coin() 和 pass() 委托给当前的状态对象

public class Turnstile {
//re
b2ac
place state types with state objects
public static final TurnstileState lockedState = new LockedTurntileState();
public static final TurnstileState unlockedState = new UnlockedTurnstileState();

private TurnstileController controller;
private TurnstileState state = lockedState;//初始的状态对象

public Turnstile(TurnstileController controller) {
this.controller = controller;
}
public void coin() {
state.coin(this); //delegate state object
}
public void pass() {
state.pass(this); ////delegate state object
}
public void unlock() {
controller.unlock();
}
public void lock() {
controller.lock();
}
public void alarm() {
controller.alarm();
}
public void thankyou() {
controller.thankyou();
}
public boolean isLocked() {
return state == lockedState;
}
public void setLocked() {
state = lockedState;
}
public boolean isUnlocked() {
return state == unlockedState;
}
public void setUnlocked() {
state = unlockedState;
}
}

通过将Context类中的State变量封装成状态类，状态相关的行为委托到状态对象上，从而去除Context中状态相关的方法中复杂状态改变条件语句。