Java设计模式-状态模式

状态模式

1.状态模式含义

状态模式就是，当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。
上面这个含义看着有点晦涩难懂，其实简单点说就是当控制一个对象状态转换的条件表达式过于复杂的情况下，将这些状态判断的逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简单化。
再简单点说，就是比如对一个对象的某个属性状态判断的时候，使用了5个10个或者更多的if…else分支判断，那么这些if…else就可以转移到能够表示不同状态的一系列的类中。

比如现在有一个类，类的某个方法中对状态做了大量的分支判断，代码如下

public class WorkOriginal {
    private int hour;
    private boolean finish = false;

    private WorkState workState;

    public WorkOriginal() {
        workState = new ForenoonState();
    }

    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 WorkState getWorkState() {
        return workState;
    }

    public void setWorkState(WorkState workState) {
        this.workState = workState;
    }

    public void writeProgram(){
//        workState.writeProgram(this);
        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 MainApp {
    public static void main(String[] args) {
        WorkOriginal workOriginal = new WorkOriginal();
        workOriginal.setHour(10);
        workOriginal.writeProgram();
        workOriginal.setHour(12);
        workOriginal.writeProgram();
        workOriginal.setHour(14);
        workOriginal.writeProgram();
        workOriginal.setHour(17);
        workOriginal.writeProgram();
        workOriginal.setHour(18);
        workOriginal.writeProgram();
        workOriginal.setHour(20);
        workOriginal.writeProgram();
        workOriginal.setHour(22);
        workOriginal.writeProgram();
    }
}

运行结果

当前时间10点，上午写代码
当前时间12点，饿了，午休
当前时间14点，下午写代码
当前时间17点，代码还没写完，加会班
当前时间18点，代码还没写完，加会班
当前时间20点，代码还没写完，加会班
当前时间22点，不行了，干不动了，睡觉睡觉

如上述代码，我们的WorkOriginal类的writeProgram()方法里面的判断逻辑太多，导致该方法过长，这在编码规范中属于坏味道。并且因为分支很多，所以这个方法的责任就很重，这也违背了设计模式的单一职责原则。

下面使用状态模式对其进行改造

2.状态模式代码改造

新WorkOriginal类

public class WorkOriginal {
    private int hour;
    private boolean finish = false;

    private WorkState workState;

    public WorkOriginal() {
        workState = new ForenoonState();
    }

    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 WorkState getWorkState() {
        return workState;
    }

    public void setWorkState(WorkState workState) {
        this.workState = workState;
    }

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

2.1WorkState抽象类

WorkState抽象类用来定义一个接口以封装writeProgram这个行为

public abstract class WorkState {
    public abstract void writeProgram(WorkOriginal workOriginal);
}

2.2ForenoonState类

ForenoonState是WorkState的具体实现子类，表示上午工作的状态判断

public class ForenoonState extends WorkState{
    @Override
    public void writeProgram(WorkOriginal workOriginal) {
        if (workOriginal.getHour() < 12) {
            System.out.println("当前时间" + workOriginal.getHour() + "点，上午写代码");
        } else {
            workOriginal.setWorkState(new NoonState());
            workOriginal.writeProgram();
        }
    }
}

2.3NoonState 类

NoonState是WorkState的具体实现子类，表示中午工作的状态判断

public class NoonState extends WorkState{
    @Override
    public void writeProgram(WorkOriginal workOriginal) {
        if (workOriginal.getHour() < 13){
            System.out.println("当前时间" + workOriginal.getHour()  + "点，饿了，午休");
        } else {
            workOriginal.setWorkState(new AfternoonState());
            workOriginal.writeProgram();
        }
    }
}

2.4AfternoonState 类

AfternoonState是WorkState的具体实现子类，表示下午工作的状态判断

public class AfternoonState extends WorkState{
    @Override
    public void writeProgram(WorkOriginal workOriginal) {
        if (workOriginal.getHour() < 17){
            System.out.println("当前时间" + workOriginal.getHour() + "点，下午写代码");
        } else {
            workOriginal.setWorkState(new EveningState());
            workOriginal.writeProgram();
        }
    }
}

2.5EveningState 类

EveningState是WorkState的具体实现子类，表示晚上工作的状态判断

public class EveningState extends WorkState{
    @Override
    public void writeProgram(WorkOriginal workOriginal) {
        if (workOriginal.isFinish()) {
            workOriginal.setWorkState(new RestState());
            workOriginal.writeProgram();
        } else {
            if (workOriginal.getHour() < 21) {
                System.out.println("当前时间" + workOriginal.getHour() + "点，代码还没写完，加会班");
            } else {
                workOriginal.setWorkState(new SleepingState());
                workOriginal.writeProgram();
            }
        }
    }
}

2.6 SleepingStata类

SleepingStata是WorkState的具体实现子类，表示睡觉的状态判断

public class SleepingState extends WorkState{
    @Override
    public void writeProgram(WorkOriginal workOriginal) {
        System.out.println("当前时间" + workOriginal.getHour() + "点，不行了，干不动了，睡觉睡觉");
    }
}

改造完成后，客户端代码无需任何改动，运行结果也没有任何变化。但是通过改造，原本集中在WorkOriginal类中的判断逻辑，被分散到State的五个子类中，每个子类负责对自己相关的状态做判断，若不在自己分支判断逻辑中，则将状态传递到下一个子类中进行判断。

3.总结

状态模式其实可以简单点来理解，就是如果一个类中对状态的判断使用了很多的分支结构，导致状态判断的方法异常复杂，这个时候就可以使用状态模式进行改造。
状态模式的代码结构挺简单的，要是不太懂的话，可以将样例代码多敲两遍。