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

举个栗子

问题描述

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

简单实现

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 的子类之间，来减少相互间的依赖。
• 当一个对象的行为取决于它的状态，并且必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。