状态模式

状态模式的定义

定义：当一个对象内在状态改变时允许其改变行为，这个对象看起来就像改变了其类。
状态模式的核心是封装，状态的变更引起了行为的变更，从外部看了起来好像这个对象对应的类发生了改变一样，状态模式的通用类图如下：

角色的定义

• state——抽象状态角色
  接口或抽象类，负责对象状态定义，并且封装环境角色以实现状态切换。
• ConcreteState——具体状态角色
  每一个具体状态必须完成两个职责：本状态的行为管理以及趋向状态处理，通俗地说，就是本状态下要做的事情，以及本状态如何过渡到其他状态。
• Context——环境角色
  定义客户端需要的接口，并且负责具体状态的切换。

状态模式相对来说比较复杂，它提供了一种对物质运动的另一个观察视角，通过状态变更促使行为的变化，就类似于水的状态变更一样，一碗水的初始状态是液态，通过加热转变为气态，状态的改变同时也引起体积的扩大，然后就产生了一个新的行为：鸣笛或顶起壶盖。

通用源码如下：
抽象环境角色

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();
}

抽象环境中申明一个环境角色，提供各个状态自行访问，并提供所有状态的抽象行为，由各个实现类实现。
环境角色

public class ConcreteState1 extends State {
     @Override
     public void handle1() {
             //本状态下必须处理的逻辑
     }
     @Override
     public void handle2() {
             //设置当前状态为stat2
             super.context.setCurrentState(Context.STATE2);
             //过渡到state2状态，由Context实现
             super.context.handle2();
     }
}
public class ConcreteState2 extends State {
     @Override
     public void handle1() {
             //设置当前状态为state1
             super.context.setCurrentState(Context.STATE1);
             //过渡到state1状态，由Context实现
             super.context.handle1();
     }
     @Override
     public void handle2() {
             //本状态下必须处理的逻辑
     }
}

具体环境角色有两个职责：处理本状态必须完成的任务，决定是否可以过渡到其他状态。
具体环境角色

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();
     }
}

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

• 把状态对象声明为静态常量，有几个状态就声明几个静态常量。
• 环境角色具有状态抽象角色定义的所有行为，具体执行使用委托方式。

具体场景

public class Client {
     public static void main(String[] args) {
             //定义环境角色
             Context context = new Context();
             //初始化状态
             context.setCurrentState(new ConcreteState1());
             //行为执行
             context.handle1();
             context.handle2();
     }
}

我们隐藏了状态的变化过程，它的切换引起了行为的变化。对外来说，我们只看到行为的发生改变，而不用知道是状态变化引起的。

状态模式的应用

状态模式的优点

• 结构清晰
  避免了过多的switch...case或者if...else语句的使用，避免了程序的复杂性，提高系统的可维护性。
• 遵循设计原则
  很好地体现了开闭原则和单一职责原则，每个状态都是一个子类，你要增加状态就要增加子类，你要修改状态，你只修改一个子类就可以了。
• 封装性非常好
  这是状态模式的基本要求，状态变换放置到类的内部来实现，外部的调用不用知道类内部如何实现状态和行为的变化。

状态模式的缺点

子类会太多，也就是类膨胀。如果一个事物有很多个状态也不稀奇，如果完全使用状态模式就会有太多的子类，不好管理。

状态模式的使用场景

• 行为随状态改变而改变的场景
  这也是状态模式的根本出发点，例如权限设计，人员的状态不同即使执行相同的行为结果也会不同，在这种情况下 需要考虑使用状态模式。
• 条件、分支判断语句的替代者
  在程序中大量使用switch语句或者if判断语句会导致程序结构不清晰，逻辑混乱，使用状态模式可以很好地避免这一问题，它通过扩展子类实现了条件的判断处理。

状态模式的注意事项

状态模式适用于当某个对象在它的状态发生改变时，它的行为也随着发生比较大的变化，也就是说在行为状态约束下可以使用状态模式，而且使用时对象的状态最好不要超过5个。

示例

模拟电梯的运行情况，电梯具有的一些动作：开门、关门、运行、停止。
电梯的状态与动作之间的关系如下如：

	开门(open)	关门(close)	运行(run)	停止(stop)
敞门状态	X	√	X	X
闭门状态	√	X	√	√
运行状态	X	X	X	√
停止状态	√	X	√	X

以状态为导向，就是根据不同状态可执行不同的动作，类图如下：

在类图中，定义了一个LiftState抽象类，声明了一个受保护的类型Context变量，这个是串联各个状态的封装类。封装的目的很明显，就是对电梯内部状态的变化不被调用类知晓，也就是迪米特法则了，并且还定义了4个具体的实现类，承担的是状态的生产及状态间的转换过度。
抽象电梯状态

public abstract class LiftState{
     //定义一个环境角色，也就是封装状态的变化引起的功能变化
     protected Context context;
     public void setContext(Context context){
             this.context = context;
     }
     //首先电梯门开启动作
     public abstract void open();
     //电梯门有开启，那当然也就有关闭了
     public abstract void close();
     //电梯要能上能下，运行起来
     public abstract void run();
     //电梯还要能停下来
     public abstract void stop();
}

敞门状态

public class OpeningState extends LiftState{
    @Override
    public void open() {
        System.out.println("电梯门开启");
    }

    @Override
    public void close() {
        super.context.setLiftState(Context.CLOSING_STATE);
        super.context.getLiftState().close();
    }

    @Override
    public void run() {
        //门开着，电梯不能运行
        //do nothing
    }

    @Override
    public void stop() {
        //门开着，电梯就处于停止状态
        //do nothing
    }
}

Openning状态是由open0方法生的，因此，在这个方法中有一个具体的业务逻辑，我们是用print来代替了。在Openning状态下,电梯能过渡到其他什么状态呢？按照现在的定义的是只能过渡到Closing状态，因此我们在Close(中定义了状态变更，同时把Close这个动作也委托了给CloseState类下的Close方法执行，这个可能不好理解,我们
再看看Context类可能好理解点
上下文类

public class Context {
    //定义出所有的电梯状态
    public final static OpeningState OPENING_STATE = new OpeningState();
    public final static ClosingState CLOSING_STATE = new ClosingState();
    public final static RunningState RUNNING_STATE = new RunningState();
    public final static StoppingState STOPPING_STATE = new StoppingState();


    //定义一个当前电梯状态
    private LiftState liftState;
    public void setLiftState(LiftState liftState) {
        this.liftState = liftState;
        this.liftState.setContext(this);
    }
    public LiftState getLiftState() {
        return liftState;
    }

    public void open() {
        this.liftState.open();
    }

    public void close() {
        this.liftState.close();
    }

    public void run() {
        this.liftState.run();
    }

    public void stop() {
        this.liftState.stop();
    }
}

结合以上3个类，我们可以这样理解:Context是一个环境角色,它的作用是串联各个状态的过渡，在LiftSate抽象类中我们定义并把这个环境角色聚合进来,并传递到子类,也就是4个具体的实现类中自己根据环境来决定如何进行状态的过渡。

关闭状态

public class ClosingState extends LiftState {
    @Override
    public void open() {
        //电梯门关了，可以再打开
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.getLiftState().open();
    }

    @Override
    public void close() {
        System.out.println("电梯门关闭");
    }

    @Override
    public void run() {
        //电梯门是关闭着的，可以运行
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.getLiftState().run();

    }

    @Override
    public void stop() {
        //电梯门关着的，可以停止
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.getLiftState().stop();
    }
}

运行状态

public class RunningState extends LiftState{
    @Override
    public void open() {
        //电梯运行时，不能打开
        //do nothing
    }

    @Override
    public void close() {
        //电梯运行时，门就是关着的
        //do nothing
    }

    @Override
    public void run() {
        System.out.println("电梯上下运行");
    }

    @Override
    public void stop() {
        //电梯运行这，可以停止
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.getLiftState().stop();
    }
}

停止状态

public class StoppingState extends LiftState{
    @Override
    public void open() {
        //停止状态，可以开门
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.getLiftState().open();
    }

    @Override
    public void close() {
        //停止状态，门就是关闭的
        //do nothing
    }

    @Override
    public void run() {
        //停止状态可以运行
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.getLiftState().run();
    }

    @Override
    public void stop() {
        System.out.println("电梯停止了");
    }
}

场景类

public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.setLiftState(Context.CLOSING_STATE);

        context.open();
        context.close();
        context.run();
        context.stop();
    }
}