设计模式 _第十四招式_状态模式

一、定义

当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类，状态模式的核心是封装，状态的变更引起行为的变更，从外面看起来就像这个对象对应的类发生了改变一样。

二、代码演示

2.1 通用类图

2.2 角色说明

• State–抽象状态角色

  接口或抽象类，负责对象状态定义，并且封装环境角色以实现状态切换。

• ConcreteSate–具体状态角色

  每一个具体状态必须要完成两个职责：本状态行为管理及趋向状态处理，通俗的说就是本状态要做的事情， 及如何过渡到其它状态。

• Context–环境角色

  定义客户端需要的接口，并且负责到状态的切换。

状态模式相对比较复杂，它提供了一种对物质运动的一个观察视角，通过状态变更促使行为的变化，这类似水的状态变更一样。 一碗水初始状态是液体，通过加热转换为气态，状态的改变引起了体积变大。这就是蒸汽机的原理。

2.3 抽象状态角色

抽象状态角色，声明一个环境角色， 提供给各状态类自行访问，并且提供了各个状态的抽象行为。

package com.design.state.pattern;

/**
 * @description TODO
 * @date: 2019/9/21 23:09
 * @version: v 0.1
 */
public abstract class State {
    //定义一个环境角色，提供子类访问
    protected Context context;

    public void setContext(Context context) {
        this.context = context;
    }
    //行为1
    public  abstract  void  handle1();
    //行为2
    public  abstract  void  handle2();
}

           

2.4 具体状态角色

每一个具体状态必须要完成两个职责：本状态行为管理及趋向状态处理，通俗的说就是本状态要做的事情， 及如何过渡到其它状态。

package com.design.state.pattern;

/**
 * @description TODO
 * @date: 2019/9/21 23:13
 * @version: v 0.1
 */
public class ConcreteState1 extends State {
    @Override
    public void handle1() {
        System.out.println("ConcreteState1.handle1 TODO");
        //本状态必须处理的逻辑
    }

    @Override
    public void handle2() {
        //设置当前状态是state2
        super.context.setCurrentState(Context.STATE2);
        //过渡到state2状态，有context实现
        super.context.handle2();
    }
}

           

package com.design.state.pattern;

/**
 * @description TODO
 * @date: 2019/9/21 23:13
 * @version: v 0.1
 */
public class ConcreteState2 extends State {
    @Override
    public void handle2() {
        System.out.println("ConcreteState1.handle2 TODO");
        //本状态必须处理的逻辑
    }

    @Override
    public void handle1() {
        //设置当前状态是state2
        super.context.setCurrentState(Context.STATE1);
        //过渡到state2状态，有context实现
        super.context.handle1();
    }
}

           

2.5 环境角色

package com.design.state.pattern;

/**
 * @description TODO
 * @date: 2019/9/21 23:17
 * @version: v 0.1
 */
public class Context {
    //定义状态
    public final static State STATE1 = new ConcreteState1();
    public final static State STATE2 = new ConcreteState2();
    //当前状态
    private State CurrentState;

    //获取当前状态
    public State getCurrentState() {
        return CurrentState;
    }

    //设置当前状态
    public void setCurrentState(State _currentState) {
        this.CurrentState = _currentState;
        //切换状态
        this.CurrentState.setContext(this);
    }

    //行为委托
    public void handle1() {
        this.CurrentState.handle1();
    }

    //行为委托
    public void handle2() {
        this.CurrentState.handle2();
    }
}

           

环境角色有两个不成文的约束：

1）把状态对象声明为常量，有几个状态对象就声明几个静态常量。

2）环境角色具有状态抽象角色定义的所有行为，具体执行使用委托方式。

2.6 验证场景类

package com.design.state.pattern;

/**
 * @description TODO
 * @date: 2019/9/21 23:09
 * @version: v 0.1
 */
public abstract class State {
    //定义一个环境角色，提供子类访问
    protected Context context;

    public void setContext(Context context) {
        this.context = context;
    }

    //行为1
    public abstract void handle1();

    //行为2
    public abstract void handle2();
}

           

2.7 运行结果

ConcreteState1.handle1 TODO
ConcreteState2.handle2 TODO
           

三、优点

3.1 结构清晰

避免过多使用 switch…case或if…else 语句，避免了程序的复杂性，提高了可维护性。

3.2 遵循设计原则

提现了开闭原则和单一职责原则，每个状态都是一个子类。

3.3 封闭性好

状态变更是放在类的内部实现的， 外部调用不知道内部状态变更逻辑。

四、缺点

可能会出现，子类太多导致，类膨胀。

五、应用场景

• 行为随状态改变而改变的场景。
• 条件、分支判断的替代者，在程序中大量使用switch、if导致逻辑混乱，使用状态模式时，可以通过扩展子类实现条件的判断处理。

六、注意事项

使用对象的状态最好不要超过5个。