[设计模式]状态模式

开始写设计模式系列,希望自己可以坚持下来.
第六篇:状态模式

什么是状态模式

当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。

---

很多人都会疑问状态模式和策略模式的区别在哪？实际上状态模式和策略模式很相似，甚至他们的UML图都是一致的，那么他们的区别在哪呢？我们再来回想下策略模式，

• 策略模式：创建一个策略的抽象，在这个接口声明算法函数，创建不同的策略实现类来实现算法，在Context类里，外部模块通过更换不同的策略实现从而达到不同的效果。策略模式的行为是相互独立的，可以相互替换的。
• 状态模式：状态模式的创建过程和策略模式一致，但是他的目的和意图却完全不同，状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。用户不应该来指定状态（除了初始状态），而是在满足一定条件下内部将其状态自动切换。

火车的状态模式：

在生活中火车经历的状态一般是从发车->加速->减速->加速…..->减速->停车，那么我们来实现它：
State状态接口：

package top.huyuxin.statemodel;

public interface State {

  abstract void run(int speed);

}

发车状态：

package top.huyuxin.statemodel;

public class StartState implements State {

    @Override
    public void run(int speed) {
        // 当前为发车状态，火车开始提速
        System.out.println("火车开车正在提速！");
        Context.Handle.getInstance().setState(new SpeedState());
    }
}

加速状态：

package top.huyuxin.statemodel;

public class SpeedState implements State {

    @Override
    public void run(int speed) {
        if(speed>=350){
            System.out.println("到达时速上限，开始减速！");
            Context.Handle.getInstance().setState(new SlowState());
        }else{
            System.out.println("火车当前时速："+speed+",正在加速！");
            Context.Handle.getInstance().speed+=50;
        }
    }

}

减速状态：

package top.huyuxin.statemodel;

public class SlowState implements State {

    @Override
    public void run(int speed) {
        if(speed<250){
            System.out.println("到达时速下限，开始减速！");
            Context.Handle.getInstance().setState(new SpeedState());
        }else{
            System.out.println("火车当前时速："+speed+",正在减速！");
            Context.Handle.getInstance().speed-=50;
        }
    }

}

停车状态：

package top.huyuxin.statemodel;

public class StopState implements State{

    @Override
    public void run(int speed) {
        System.out.println("火车准备停靠，开始减速,当前时速："+speed);
        Context.Handle.getInstance().speed-=50;
        if(Context.Handle.getInstance().speed==0){
            System.out.println("火车停止运行停靠成功！");
        }
    }


}

Context:

package top.huyuxin.statemodel;

public class Context {

    public int speed=0;//时速
    public int distance=0;//距离

    private Context() {
        super();
    }

    public static class Handle{
        private static Context context=new Context();
        public static Context getInstance() {
            return context;
        }
    }

    private State state;

    /**
     * protected 防止外部模块修改状态
     * @param state
     */
    protected void setState(State state) {
        this.state = state;
    }

    public void run(){
        if(state==null){
            state=new StartState();
        }
        for(;;){
            state.run(speed);
            distance+=10;
            //开始停靠
            if(distance>300){
                state=new StopState();
                if(speed==-50){
                    break;
                }
            }
        }
    }
}

Main：

package top.huyuxin.statemodel.main;

import top.huyuxin.statemodel.Context;
import top.huyuxin.statemodel.Context.Handle;

public class Main {

    public static void main(String[] args) {

        Context.Handle.getInstance().run();

    }
}

输出：

火车开车正在提速！
火车当前时速：0,正在加速！
火车当前时速：50,正在加速！
火车当前时速：100,正在加速！
火车当前时速：150,正在加速！
火车当前时速：200,正在加速！
火车当前时速：250,正在加速！
火车当前时速：300,正在加速！
到达时速上限，开始减速！
火车当前时速：350,正在减速！
火车当前时速：300,正在减速！
火车当前时速：250,正在减速！
到达时速下限，开始减速！
火车当前时速：200,正在加速！
火车当前时速：250,正在加速！
火车当前时速：300,正在加速！
到达时速上限，开始减速！
火车当前时速：350,正在减速！
火车当前时速：300,正在减速！
火车当前时速：250,正在减速！
到达时速下限，开始减速！
火车当前时速：200,正在加速！
火车当前时速：250,正在加速！
火车当前时速：300,正在加速！
到达时速上限，开始减速！
火车当前时速：350,正在减速！
火车当前时速：300,正在减速！
火车当前时速：250,正在减速！
到达时速下限，开始减速！
火车当前时速：200,正在加速！
火车当前时速：250,正在加速！
火车准备停靠，开始减速,当前时速：300
火车准备停靠，开始减速,当前时速：250
火车准备停靠，开始减速,当前时速：200
火车准备停靠，开始减速,当前时速：150
火车准备停靠，开始减速,当前时速：100
火车准备停靠，开始减速,当前时速：50
火车停止运行停靠成功！

其实经过这样简单的倒腾这已经是一个简易的有限状态机。当然按关于简易有限状态机的实现，网上还有一种利用enum(枚举)的实现方式，当状态比较简单还是可以使用的，但是状态过多时不建议使用，这会使得代码的可读性变得十分差。

扩展

在我们生活中还有很多的在这种情况，比如电梯在运行时他的状态应该是，开门->关门->升降->停止->开门->关门，在升降的过程中是不可能执行开门状态的，关门和开门进行时却可以自由切换，等等这些复杂的状态处理。我们可以通过建立链表关系，二叉树等数据结构的关系来实现。