大话设计模式笔记（十三）の状态模式

举个栗子

问题描述

上班的日子，上午状态好，中午想睡觉，下午渐恢复，加班苦煎熬。根据时间的不一样体现不一样的工做状态。

简单实现

Work

/**
 * 工做类
 * Created by callmeDevil on 2019/8/3.
 */
public class Work {

    private int hour;
    private boolean finish = false;

    public void writeProgram() {
        if (hour < 12) {
            System.out.println(String.format("当前时间：%s点，上午工做，精神百倍", hour));
        } else if (hour < 13) {
            System.out.println(String.format("当前时间：%s点，饿了，午餐；犯困，午休", hour));
        } else if (hour < 17) {
            System.out.println(String.format("当前时间：%s点，下午状态还不错，继续努力", hour));
        } else {
            if (finish) {
                System.out.println(String.format("当前时间：%s点，下班回家了", hour));
            } else {
                if (hour < 21) {
                    System.out.println(String.format("当前时间：%s点，加班哦，疲累至极", hour));
                } else {
                    System.out.println(String.format("当前时间：%s点，不行了，睡着了", hour));
                }
            }
        }
    }

    // 省略 get set 方法

}

测试

public class Test {
    public static void main(String[] args) {
        // 紧急项目
        Work emergencyProjects = new Work();
        emergencyProjects.setHour(9);
        emergencyProjects.writeProgram();
        emergencyProjects.setHour(10);
        emergencyProjects.writeProgram();
        emergencyProjects.setHour(11);
        emergencyProjects.writeProgram();
        emergencyProjects.setHour(12);
        emergencyProjects.writeProgram();
        emergencyProjects.setHour(13);
        emergencyProjects.writeProgram();
        emergencyProjects.setHour(14);
        emergencyProjects.writeProgram();
        emergencyProjects.setHour(17);
        emergencyProjects.writeProgram();
        emergencyProjects.setHour(19);
        emergencyProjects.writeProgram();
        emergencyProjects.setHour(22);
        emergencyProjects.writeProgram();
        System.out.println("--------------------------");
        emergencyProjects.setFinish(true);
        emergencyProjects.setHour(19);
        emergencyProjects.writeProgram();
        emergencyProjects.setHour(22);
        emergencyProjects.writeProgram();
    }
}

测试结果

当前时间：9点，上午工做，精神百倍
当前时间：10点，上午工做，精神百倍
当前时间：11点，上午工做，精神百倍
当前时间：12点，饿了，午餐；犯困，午休
当前时间：13点，下午状态还不错，继续努力
当前时间：14点，下午状态还不错，继续努力
当前时间：17点，加班哦，疲累至极
当前时间：19点，加班哦，疲累至极
当前时间：22点，不行了，睡着了
--------------------------
当前时间：19点，下班回家了
当前时间：22点，下班回家了

存在问题

面向对象设计其实就是但愿作到代码的责任分解。 这个类违背了“单一职责原则”。若是公司为了员工的安全而要求员工必须20点以前离开公司（想一想就好，现实每每不可能。。），那就会对当前的方法改动，维护出错的风险很大，这点来讲违背了“开放-封闭原则”。

状态模式

定义

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

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

UML图

代码实现

State

/**
 * 抽象状态
 * Created by callmeDevil on 2019/8/3.
 */
public abstract class State {
    public abstract void writeProgram(Work work);
}

ForenoonState

/**
 * 上午工做状态
 * Created by callmeDevil on 2019/8/3.
 */
public class ForenoonState extends State{
    @Override
    public void writeProgram(Work work) {
        if (work.getHour() < 12) {
            System.out.println(String.format("当前时间：%s点，上午工做，精神百倍", work.getHour()));
        } else {
            // 超过12点，转入中午工做状态
            work.setState(new NoonState());
            work.writeProgram();
        }
    }
}

NoonState

/**
 * 中午工做状态
 * Created by callmeDevil on 2019/8/3.
 */
public class NoonState extends State{
    @Override
    public void writeProgram(Work work) {
        if (work.getHour() < 13) {
            System.out.println(String.format("当前时间：%s点，饿了，午餐；犯困，午休", work.getHour()));
        } else {
            // 超过13点，转入下午工做状态
            work.setState(new AfternoonState());
            work.writeProgram();
        }
    }
}

AfternoonState

/**
 * 下午工做状态
 * Created by callmeDevil on 2019/8/3.
 */
public class AfternoonState extends State{
    @Override
    public void writeProgram(Work work) {
        if (work.getHour() < 17) {
            System.out.println(String.format("当前时间：%s点，下午状态还不错，继续努力", work.getHour()));
        } else {
            // 超过17点，转入傍晚工做状态
            work.setState(new EveningState());
            work.writeProgram();
        }
    }
}

EveningState

/**
 * 傍晚工做状态
 * Created by callmeDevil on 2019/8/3.
 */
public class EveningState extends State {
    @Override
    public void writeProgram(Work work) {
        if (work.isTaskFinished()) {
            // 若是完成任务，转入下班状态
            work.setState(new RestState());
        } else {
            if (work.getHour() < 21) {
                System.out.println(String.format("当前时间：%s点，加班哦，疲累至极", work.getHour()));
            } else {
                // 超过21点，转入睡眠工做状态
                work.setState(new SleepingState());
                work.writeProgram();
            }
        }
    }
}

SleepingState

/**
 * 睡眠工做状态
 * Created by callmeDevil on 2019/8/3.
 */
public class SleepingState extends State{
    @Override
    public void writeProgram(Work work) {
        System.out.println(String.format("当前时间：%s点，不行了，睡着了", work.getHour()));
    }
}

RestState

/**
 * 下班工做状态
 * Created by callmeDevil on 2019/8/3.
 */
public class RestState extends State{
    @Override
    public void writeProgram(Work work) {
        System.out.println(String.format("当前时间：%s点，下班回家了", work.getHour()));
    }
}

Work

/**
 * 工做类，此时没有了过长的分支判断语句
 * Created by callmeDevil on 2019/8/3.
 */
public class Work {

    private State current;
    private int hour; // 时间，状态转换的依据
    private boolean taskFinished; // 任务完成，是否能下班的依据

    public Work(){
        // 工做初始化为上午工做状态，即上午9点开始上班
        current = new ForenoonState();
    }

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

    // 省略 get set 方法

}

测试代码与测试结果同上。

总结

• 好处是将与特定状态相关的行为局部化，而且将不一样状态的行为分割开来。
• 将特定的状态相关的行为都放入一个对象中，因为全部与状态相关的代码都存在于某个 ConcreteState 中，因此经过定义新的子类能够很容易的增长新的状态和转换。
• 状态模式经过把各类状态转移逻辑分布到 State 的子类之间，来减小相互间的依赖。
• 当一个对象的行为取决于它的状态，而且必须在运行时根据状态改变它的行为时，就能够考虑使用状态模式。