设计模式[20]-状态模式-State Pattern

1.状态模式简介

状态模式(State Pattern)模式是行为型(Behavioral)设计模式，允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。这个定义很拗口，很抽象，等看完了例子，我们在总结时，再换一个方式来描述。

当一个对象有多种状态，状态之间可以互相转化，每种状态的行为不相同，就可以使用状态模式。对于客户端而言，不需要知道对象当前的状态，不需要关心状态变迁的逻辑。

状态模式一共有三种角色：

(1) Context（环境类）：环境类又称为上下文类，持有状态对象，具备切换状态的行为。

(2) State（抽象状态类）：定义一个接口，用以封装环境（Context）对象的一个特定的状态所对应的行为。

(3) ConcreteState（具体状态类）：每一个具体状态类都实现了环境（Context）的一个状态所对应的行为。

2. 状态模式举例

下面模拟风扇换挡的操作，简单起见，风扇仅有off(关闭)、low(低挡）、high（高挡）三个挡位（状态）；每个挡位对应的行为都不同。

序号	类名	角色	说明
1	FanContext	Context	上下文类
2	FanState	State	抽象状态类
3	FanOffState	ConcreteState	具体状态类，风扇处于OFFf状态
4	FanLowState	ConcreteState	具体状态类，风扇处于LOW状态
5	FanHighState	ConcreteState	具体状态类，风扇处于HIGH状态
6	StateMain	客户端	演示调用

State Pattern.png

1. FanContext 上下文类

public class FanContext {

    public final static FanState OFF = new FanOffState();
    public final static FanState LOW = new FanLowState();
    public final static FanState HIGH = new FanHighState();

    private FanState fanState;

    // 初始化时，风扇位于OFF挡
    public FanContext() {
        fanState = OFF;
        fanState.setFanContext(this);
    }

    public FanState getFanState() {
        return fanState;
    }

    public void setFanState(FanState fanState) {
        this.fanState = fanState;
        // 换挡时，把context设入
        fanState.setFanContext(this);
    }

    public void turnOff() {
        fanState.turnOff();
    }

    public void shiftHigh() {
        fanState.shiftHigh();
    }

    public void shiftLow() {
        fanState.shiftLow();
    }
}

2. FanState 抽象状态类，定义了状态对应的抽象行为

public abstract class FanState {

    protected FanContext fanContext;

    public void setFanContext(FanContext fanContext) {
        this.fanContext = fanContext;
    }
    // 关风扇
    abstract void turnOff();
    // 调到高挡
    abstract void shiftHigh();
    // 调到低挡
    abstract void shiftLow();
}

3. FanOffState，具体状态类

/**
 * 具体状态类，风扇处于OFF状态；可以调到低挡或者调到高挡。
 */
public class FanOffState extends FanState {

    @Override
    public void turnOff() {
        System.out.println("风扇关闭");
    }

    @Override
    public void shiftHigh() {
        // 把上下文切换到FanHighState
        super.fanContext.setFanState(FanContext.HIGH);
        // 调用FanHighState，调至高挡
        super.fanContext.getFanState().shiftHigh();
    }

    @Override
    public  void shiftLow() {
        // 把上下文切换到FanLowState
        super.fanContext.setFanState(FanContext.LOW);
        // 调用FanLowState，调至低挡
        super.fanContext.getFanState().shiftLow();
    }
}

4. FanLowState，具体状态类

/**
 * 具体状态类，风扇处于LOW状态；可以关闭或者调到高挡。
 */
public class FanLowState extends FanState {

    @Override
    public void turnOff() {
        // 把上下文切换到FanOffState，并调用其关闭操作。
        super.fanContext.setFanState(FanContext.OFF);
        super.fanContext.getFanState().turnOff();
    }

    @Override
    public void shiftHigh() {
        // 把上下文切换到FanHighState，并调用其升挡操作。
        super.fanContext.setFanState(FanContext.HIGH);
        super.fanContext.getFanState().shiftHigh();
    }

    @Override
    public void shiftLow() {
        System.out.println("风扇调整到了低挡");
    }
}

**5.FanHighState，具体状态类 **

/**
 * 具体状态类，风扇处于HIGH状态；可以关闭或者调到低挡。
 */
public class FanHighState extends FanState {

    @Override
    public void turnOff() {
        // 把上下文切换到FanOffState，并调用其关闭操作。
        super.fanContext.setFanState(FanContext.OFF);
        super.fanContext.getFanState().turnOff();
    }

    @Override
    public void shiftHigh() {
        System.out.println("风扇调整到了高挡");
    }

    @Override
    public void shiftLow() {
        // 把上下文切换到FanLowState，并调用其降挡操作。
        super.fanContext.setFanState(FanContext.LOW);
        super.fanContext.getFanState().shiftLow();
    }
}

4. StateMain 演示类

public class StateMain {

    public static void main(String[] args) {
        // 初始化上下文
        FanContext fanContext = new FanContext();
        // 调到高
        fanContext.shiftHigh();
        // 调到低挡
        fanContext.shiftLow();
        // 关闭
        fanContext.turnOff();
    }
}

结果输出

风扇调整到了高挡
风扇调整到了低挡
风扇关闭

3. 总结

状态模式将一个对象在不同状态下的不同行为封装到一个个类中，通过设置不同的状态对象，让上下文类具备不同的行为。具体到我们举得例子中，风扇在不同的挡位具有不同的行为，例子中每个挡位都封装成了一个类；通过设置FanContext中不同的FanState，从而是FanContext具备了不同的行为。

状态模式封装了状态的转换规则，将某个状态有关的行为都封装在一个类中，只需要在上下文类中注入不同的状态类，环境类就可以有不同的行为，避免了大量写if else 语句。

状态模式的使用必然会增加系统中的类和对象的数目，设计难度变大，系统运行开销变大；如果要新增状态类，则必然要修改负责状态转换的代码。

策略模式和状态模式

状态模式和策略模式的类图看起来简直就是一样的，都如下图所示。状态模式和策略模式的实现方法非常类似，都是利用多态把一些操作分配到一组相关的简单的类中。

适用场景不同：这一点就是状态和策略的不同，对象的状态，例如工作流、界面的按钮操作、电梯的状态，其核心是状态的变迁；策略常用的场景比如电商的折扣策略等。

客户端感知不同：在状态模式中，状态的变迁是由对象的内部条件决定，客户端只需关心其接口，不必关心其状态对象的创建和转化；而策略模式里，采取何种策略由客户端决定的。

类图相似

策略模式的连接：http://www.jianshu.com/p/90759e153ac9

（完）