设计模式之状态模式

参考博客文章：https://www.cnblogs.com/pony1223/p/7518226.html

状态模式 State

2019-06-25  11:18:28

什么是状态模式：允许一个对象在其内部状态改变时自动改变其行为。

对象中部分行为是随着状态的变化而变化的，将变化的这部分抽象出来，并依赖该抽象类。

适用性：每个对象都有其对应的状态，而每个状态又对应一些相应的行为，这些行为又可能改变其状态。

状态模式的优点：

　　思考场景：对象有三个状态A、B、C，三个操作opration1()、opration2()、opration3()，不同状态下三个操作方式均不同。　　

　　不使用状态模式：三个操作中含有大量 if-else 的判断代码块，然后在if-else 的判断代码块中做相应的操作并改变状态。这样的设计方式扩展性差。

　　使用状态模式：因为三个操作均有多种实现，参考策略模式，将三个操作方法抽象到基类。需要这些操作的对象内部引用该基类。为了状态的转换，在基类中维护下一状态。

状态模式成员：Context、State、ConcreteState

　　Context：需要调用三个操作opration1()、opration2()、opration3()的类，维护一个State成员，通过多态机制传入ConcreteState。

　　State：抽象状态类，抽象了所有因状态不同而变化的方法，并维护下一状态成员变量。

　　ConcreteState：具体状态类，具体实现了在不同状态下的方法。

状态模式基本代码：

/**
 * 抽象状态类
 * 将变化的opration方法抽象出来，Context依赖State，而State是稳定的，符合原则
 */
public abstract class State {
    public State nextState;
    public abstract void opration1();
    public abstract void opration2();
    public abstract void opration3();
}

/**
 * 开状态
 */
class OpenState extends State{
    /*
    单例模式
　　只需要一个对象
     */
    private OpenState(){}
    private static class SingletonHolder{
        private static OpenState openState = new OpenState();
    }
    public static OpenState getInstance(){
        return SingletonHolder.openState;
    }

    @Override
    public void opration1() {
        System.out.println("OpenState opraytion1");
        nextState = CloseState.getInstance();
    }

    @Override
    public void opration2() {
        System.out.println("OpenState opraytion2");
        nextState = CloseState.getInstance();
    }

    @Override
    public void opration3() {
        System.out.println("OpenState opraytion3");
        nextState = CloseState.getInstance();
    }
}

/**
 * 关状态
 */
class CloseState extends State{
    /*
    单例模式
     */
    private CloseState(){}
    private static class SingletonHolder{
        private static CloseState closeState = new CloseState();
    }
    public static CloseState getInstance(){
        return SingletonHolder.closeState;
    }

    @Override
    public void opration1() {
        System.out.println("CloseState opraytion1");
        nextState = OpenState.getInstance();
    }

    @Override
    public void opration2() {
        System.out.println("CloseState opraytion2");
        nextState = OpenState.getInstance();
    }

    @Override
    public void opration3() {
        System.out.println("CloseState opraytion3");
        nextState = OpenState.getInstance();
    }
}

/**
 * context
 */
class Context{
    private State state;

    public Context(State state) {
        this.state = state;
    }

    public void switchLight1(){
        state.opration1();
        state = state.nextState;
    }
    public void switchLight2(){
        state.opration2();
        state = state.nextState;
    }
    public void switchLight3(){
        state.opration3();
        state = state.nextState;
    }

}

/**
 * 测试用例
 */
class test{
    public static void main(String[] args) {
        Context context = new Context(OpenState.getInstance());
        context.switchLight1();
        context.switchLight2();
        context.switchLight3();
    }
}