行为型设计模式——状态模式
状态模式
状态模式是比较简单的设计模式，它的主要作用是减少代码中大量的 if-else 或者 switch-case 等逻辑判断（俗称屎山）。它将每个状态定义为一个类，而每个状态类有自己对应的方法，因此当需要根据状态执行逻辑代码时不需要写大量的if-else判断是哪个状态然后执行对应的逻辑，而只需要创建某个状态对象，直接调用它对应的方法即可。定义： 对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。
状态模式包含以下主要角色。
- 环境（Context）角色：也称为上下文，它定义了客户程序需要的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。
- 抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为。
- 具体状态（Concrete State）角色：实现抽象状态所对应的行为。
案例
【例】通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。
下面使用一个例子来说明，第一个代码的实现是不使用状态模式的实现，而是每个方法都去判断当前状态情况然后执行对应的逻辑。类图如下：
代码如下：
public interface ILift {
//电梯的4个状态
//开门状态
public final static int OPENING_STATE = 1;
//关门状态
public final static int CLOSING_STATE = 2;
//运行状态
public final static int RUNNING_STATE = 3;
//停止状态
public final static int STOPPING_STATE = 4;
//设置电梯的状态
public void setState(int state);
//电梯的动作
public void open();
public void close();
public void run();
public void stop();
}
public class Lift implements ILift {
private int state;
@Override
public void setState(int state) {
this.state = state;
}
//执行关门动作
@Override
public void close() {
switch (this.state) {
case OPENING_STATE:
System.out.println("电梯关门了。。。");//只有开门状态可以关闭电梯门，可以对应电梯状态表来看
this.setState(CLOSING_STATE);//关门之后电梯就是关闭状态了
break;
case CLOSING_STATE:
//do nothing //已经是关门状态，不能关门
break;
case RUNNING_STATE:
//do nothing //运行时电梯门是关着的，不能关门
break;
case STOPPING_STATE:
//do nothing //停止时电梯也是关着的，不能关门
break;
}
}
//执行开门动作
@Override
public void open() {
switch (this.state) {
// ..... 省略大量case代码
}
}
//执行运行动作
@Override
public void run() {
switch (this.state) {
// ..... 省略大量case代码
}
}
//执行停止动作
@Override
public void stop() {
switch (this.state) {
// ..... 省略大量case代码
}
}
}
public class Client {
public static void main(String[] args) {
Lift lift = new Lift();
lift.setState(ILift.STOPPING_STATE);//电梯是停止的
lift.open();//开门
lift.close();//关门
lift.run();//运行
lift.stop();//停止
}
}
问题分析：
- 使用了大量的switch…case这样的判断（if…else也是一样)，使程序的可阅读性变差。
- 扩展性很差。如果新加了断电的状态，我们需要修改上面判断逻辑
状态设计模式实现
对上述电梯的案例使用状态模式进行改进。类图如下：
代码如下：
首先定义电梯状态类，成员变量有当前状态名字和当前管理当前状态的上下文对象Context，为什么需要这个？因为所有的状态都由Context对象统一管理，所以所有的状态都需要记住管理自己的上下文对象，这个对象只有一个被所有状态对象持有。说到低就是各个状态类维护唯一的上下文对象引用。
public abstract class LiftState {
private String stateName;
Context context; // 维护当前的Contex，全局只有一个Context，维护当前的上下文环境
public String getStateName() {
return stateName;
}
public void setStateName(String stateName) {
this.stateName = stateName;
}
public void setContext(Context context){
this.context = context;
}
public Context getContext(){
return this.context;
}
//电梯开门动作
public abstract void open();
//电梯关门动作
public abstract void close();
//电梯运行动作
public abstract void run();
//电梯停止动作
public abstract void stop();
}
然后是四种状态的实现类，如下：
// 电梯关闭门状态
public class ClosedState extends LiftState{
public ClosedState(){
this.setStateName("关闭状态");
}
// 电梯闭门(运行)状态，只可以停止
@Override
public void stop() {
// 停止电梯
System.out.println("电梯运行已经停止...");
// 修改当前上下文环境，
StoppedState stoppedState = new StoppedState();
stoppedState.setContext(this.getContext()); // 当前Context不能变，全局用一个
this.context.setCurrState(stoppedState); // 修改当前环境的状态，换状态了！
}
@Override
public void open() {
System.out.println("不执行任何命令");
}
@Override
public void close() {
System.out.println("不执行任何命令");
}
@Override
public void run() {
System.out.println("不执行任何命令");
}
}
// 电梯开门状态
public class OpenedState extends LiftState{
public OpenedState(){
this.setStateName("开启状态");
}
// 电梯门开着的状态下(停止)只能关门操作
@Override
public void close() {
// 关闭电梯门
System.out.println("电梯门已经关闭...");
// 修改当前上下文环境
ClosedState closedState = new ClosedState();
closedState.setContext(this.getContext()); // 当前Context不能变，全局用一个
this.context.setCurrState(closedState); // 修改当前环境的状态，换状态了！
}
@Override
public void open() {
System.out.println("不执行任何命令");
}
@Override
public void run() {
System.out.println("不执行任何命令");
}
@Override
public void stop() {
System.out.println("不执行任何命令");
}
}
// 电梯运行状态
public class RunningState extends LiftState{
public RunningState(){
this.setStateName("运行状态");
}
@Override
public void open() {
System.out.println("不执行任何命令");
}
@Override
public void run() {
System.out.println("不执行任何命令");
}
@Override
public void close() {
System.out.println("不执行任何命令");
}
// 电梯运行时只能停止操作
@Override
public void stop() {
// 关闭电梯门
System.out.println("电梯运行已经停止...");
// 修改当前上下文环境
StoppedState stoppedState = new StoppedState();
stoppedState.setContext(this.getContext()); // 当前Context不能变，全局用一个
this.context.setCurrState(stoppedState); // 修改当前环境的状态，换状态了！
}
}
// 电梯停止状态
public class StoppedState extends LiftState {
public StoppedState(){
this.setStateName("停止状态");
}
// 电梯停止状态(假设停止状态是关闭门的停止)只能开门或者继续运行
@Override
public void open() {
// 电梯门打开
System.out.println("电梯门已经打开...");
// 修改当前上下文环境
OpenedState openedState = new OpenedState();
openedState.setContext(this.getContext()); // 当前Context不能变，全局用一个
this.context.setCurrState(openedState); // 修改当前环境的状态，换状态了！
}
@Override
public void run() {
// 启动电梯
System.out.println("电梯运行开始启动...");
// 修改当前上下文环境
RunningState runningState = new RunningState();
runningState.setContext(this.getContext()); // 当前Context不能变，全局用一个
this.context.setCurrState(runningState); // 修改当前环境的状态，换状态了！
}
@Override
public void stop() {
System.out.println("不执行任何命令");
}
@Override
public void close() {
System.out.println("不执行任何命令");
}
}
上面这么多状态，需要有一个类来统一管理，这个类就是上下文环境类，这个类维护一个当前状态，屏蔽掉具体的状态类。这个上下文环境对象的当前状态由触发的动作决定，例如在电梯停止状态下调用open()方法，就会转变位门开启状态。如下：
public class Context {
private LiftState currState;
public Context(LiftState state){
this.currState = state;
this.currState.setContext(this);
}
public void setCurrState(LiftState state){
this.currState = state;
this.currState.setStateName(state.getStateName());
}
public LiftState getCurrState(){
return this.currState;
}
public void open(){
this.currState.open();
}
public void close() {
this.currState.close();
}
public void run() {
this.currState.run();
}
public void stop() {
this.currState.stop();
}
}
客户端测试类：
public class Main {
public static void main(String[] args) {
ClosedState closedState = new ClosedState();
Context context = new Context(closedState);
System.out.println(context.getCurrState().getStateName());
System.out.println("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
context.stop();
System.out.println(context.getCurrState().getStateName());
context.run();
System.out.println(context.getCurrState().getStateName());
context.open();
System.out.println(context.getCurrState().getStateName());
}
}
输出结果：
关闭状态
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
电梯运行已经停止…
停止状态
电梯运行开始启动…
运行状态
不执行任何命令
运行状态
解释一下Context 类中持有LiftState对象，而LiftState 类也持有Context 对象的逻辑，首先Context 中持有LiftState对象是为了维护不同状态的切换，即维护一个当前状态，当客户端调用了某个方法会触发状态的自动切换，这个Context 就是上下文或者讲环境类。而为什么LiftState 类也持有Context 对象呢？那这不是相互引用吗？是的，但是这样做是没错的，LiftState 类中的Context 对象就是一开始我们的环境上下文对象，全局只有一个，每个状态需要记住这个Context 对象的引用是因为发生状态切换的时候需要Context 对象的状态设置为自己，因此需要知道Context 对象的引用。那能不能不引用呢？也是可以的，那么需要通过传参的方式将Context 对象传进来，然后状态切换的时候设置Context 对象的当前状态即可。相互引用在Java中是常见的操作，假设A类和B类相互引用，实例化的时候先实例化A对象，其中的B引用为null，然后实例化B的时候将其B中的A引用指向上面实例化的A对象，将上面实例化的A对象B引用指向自己。延迟加载的模式进行实例化。
优点
- 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
- 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
缺点
- 状态模式的使用必然会增加系统类和对象的个数。
- 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
- 状态模式对"开闭原则"的支持并不太好。
使用场景
- 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
- 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。
参考内容
传智播客设计模式相关笔记（主要）
https://zhuanlan.zhihu.com/p/369732910