状态模式（十二）

一个例子引出状态模式：

每天的不同时间工作会有不同的工作状态，我们用面向对象来实现一下：

工作类：

public class Work {
    /**
     * 时间点
     */
    private int hour;
    /**
     * 工作是否完成
     */
    private boolean finish = false;

    public int getHour() {
        return hour;
    }

    public void setHour(int hour) {
        this.hour = hour;
    }

    public boolean isFinish() {
        return finish;
    }

    public void setFinish(boolean finish) {
        this.finish = finish;
    }

    public void writeProgram(){
        if (hour < 12){
            System.out.println("当前时间" + hour + "上午工作，精神百倍");
        } else if (hour < 13){
            System.out.println("当前时间" + hour + "饿了，午饭，犯困，休息");
        } else if (hour < 17){
            System.out.println("当前时间" + hour + "下午状态还不错，继续努力");
        } else {
            if (finish){
                System.out.println("当前时间" + hour + "下班回家了");
            } else if (hour < 21){
                System.out.println("当前时间" + hour + "加班哦，好难受");
            } else {
                System.out.println("当前时间" + hour + "不行了，睡着了");
            }
        }
    }
}

客户端代码：

public class WorkTest {
    public static void main(String[] args) {
        Work work = new Work();
        work.setHour(9);
        work.writeProgram();
        work.setHour(10);
        work.writeProgram();
        work.setHour(12);
        work.writeProgram();
        work.setHour(13);
        work.writeProgram();
        work.setHour(14);
        work.writeProgram();
        work.setHour(17);
        work.writeProgram();

        // 假设完成工作
        work.setFinish(true);
        work.writeProgram();
        work.setHour(19);
        work.writeProgram();
        work.setHour(22);
        work.writeProgram();
    }
}

输出结果：

当前时间9上午工作，精神百倍
当前时间10上午工作，精神百倍
当前时间12饿了，午饭，犯困，休息
当前时间13下午状态还不错，继续努力
当前时间14下午状态还不错，继续努力
当前时间17加班哦，好难受
当前时间17下班回家了
当前时间19下班回家了
当前时间22下班回家了

 

上面的代码虽然可以实现功能，但是方法中的代码过长，这通常不是一个好的代码，writeProgram()中不应该有太多的判断。要知道这个方法很长，而且有很多判断分支，这就意味着它的责任过大了。无论任何状态，都需要通过它来改变，这实际上是很糟糕的。

面向对象设计其实就是希望做到代码责任的分解。这个类违背了“单一职责原则”，维护出错的风险过大，所以我们可以将这些分支变为一个个的类，增加时又不会影响其它类。然后状态的变化在各自的类中完成，这种解决方案就是状态设计模式。

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

状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化。当然，如果这个状态判断逻辑很简单，那就没必要用状态模式了。

用状态模式改进后的代码：

State类，抽象状态类，定义一个接口以封装与Work的一个特定状态的行为。

public abstract class State {
    public abstract void writeProgram(Work work);
}

ForenoonState, AfternoonState, NoonState, EveningState, RestState, SleepingState类，具体状态，每一个子类实现一个与Work的一个状态相关的行为。

public class ForenoonState extends State {
    @Override
    public void writeProgram(Work work) {
        if (work.getHour() < 12){
            System.out.println("当前时间" + work.getHour() + "上午工作，精神百倍");
        } else {
            work.setState(new NoonState());
            work.writeProgram();
        }
    }
}

public class AfternoonState extends State {
    @Override
    public void writeProgram(Work work) {
        if (work.getHour() < 17){
            System.out.println("当前时间" + work.getHour() + "下午状态还不错，继续努力");
        } else {
            work.setState(new EveningState());
            work.writeProgram();
        }
    }
}

public class NoonState extends State {
    @Override
    public void writeProgram(Work work) {
        if (work.getHour() < 13){
            System.out.println("当前时间" + work.getHour() + "饿了，午饭，犯困，休息");
        } else {
            work.setState(new AfternoonState());
            work.writeProgram();
        }
    }
}

public class EveningState extends State {
    @Override
    public void writeProgram(Work work) {
        if (work.isFinish()){
            work.setState(new RestState());
            work.writeProgram();
        } else {
            if (work.getHour() < 21){
                System.out.println("当前时间" + work.getHour() + "加班哦，好难受");
            } else {
                work.setState(new SleepingState());
                work.writeProgram();
            }
        }
    }
}

public class RestState extends State {
    @Override
    public void writeProgram(Work work) {
        System.out.println("当前时间" + work.getHour() + "下班回家了");
    }
}

public class SleepingState extends State {
    @Override
    public void writeProgram(Work work) {
        System.out.println("当前时间" + work.getHour() + "不行了，睡着了");
    }
}

Work类，维护一个State子类的实例，这个实例定义当前的状态。

public class Work {
    private State state;

    public Work() {
        // 初始化为上午工作状态
        state = new ForenoonState();
    }

    private double hour;
    private boolean finish = false;

    public double getHour() {
        return hour;
    }

    public void setHour(double hour) {
        this.hour = hour;
    }

    public boolean isFinish() {
        return finish;
    }

    public void setFinish(boolean finish) {
        this.finish = finish;
    }

    public void setState(State state) {
        this.state = state;
    }

    public void writeProgram(){
        state.writeProgram(this);
    }
}

客户端代码与之前的相同，而我们的程序更加灵活多变了。这样我们就实现了将分支分离开。

状态模式的好处与用处

状态模式的好处是将与特定状态相关的行为局部化，并且将不同状态的行为分割开来。

也就是将特定的状态相关的行为都放入一个对象中，由于所有与状态相关的代码都存在于某个State的子类中，所以通过定义新的子类可以很容易地增加新的状态和转换。

这样做的目的就是为了消除庞大的分支条件语句，大的分支会导致难以修改和扩展，任何改动和变化都是致命的。状态模式通过把各种状态转移逻辑分布到State的子类之间，来减少相互间的依赖。

什么时候使用状态模式？

当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式了。