状态模式
2026/9/12大约 7 分钟
状态模式
1. 概述
【例】通过按钮来控制一个电梯的状态。一个电梯有开门状态、关门状态、停止状态、运行状态，每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯当前处于运行状态，就不能进行开门操作；而如果电梯是停止状态，就可以执行开门操作。
类图如下：
代码如下：
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 OPENING_STATE:
// do nothing 门已经开了，不能再开门了
break;
case CLOSING_STATE:
System.out.println("电梯门打开了。。。"); // 关门状态，门打开
this.setState(OPENING_STATE);
break;
case RUNNING_STATE:
// do nothing 运行时电梯不能开门
break;
case STOPPING_STATE:
System.out.println("电梯门开了。。。"); // 电梯停了，可以开门了
this.setState(OPENING_STATE);
break;
}
}
// 执行运行动作
@Override
public void run() {
switch (this.state) {
case OPENING_STATE:
// do nothing 电梯不能开着门就走
break;
case CLOSING_STATE:
System.out.println("电梯开始运行了。。。"); // 门关了，可以运行了
this.setState(RUNNING_STATE); // 现在是运行状态
break;
case RUNNING_STATE:
// do nothing 已经是运行状态了
break;
case STOPPING_STATE:
System.out.println("电梯开始运行了。。。");
this.setState(RUNNING_STATE);
break;
}
}
// 执行停止动作
@Override
public void stop() {
switch (this.state) {
case OPENING_STATE:
// do nothing 开门的电梯已经是停止的了（正常情况下）
break;
case CLOSING_STATE:
System.out.println("电梯停止了。。。"); // 关门时才可以停止
this.setState(STOPPING_STATE);
break;
case RUNNING_STATE:
System.out.println("电梯停止了。。。"); // 运行时当然可以停止了
this.setState(STOPPING_STATE);
break;
case STOPPING_STATE:
// do nothing
break;
}
}
}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也一样），使程序的可阅读性变差； - 扩展性很差。如果新加了断电的状态，我们需要修改上面所有的判断逻辑。
定义：对有状态的对象，把复杂的"判断逻辑"提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。
2. 结构
状态模式包含以下主要角色：
| 角色 | 职责 |
|---|---|
| 环境（Context）角色 | 也称为上下文，定义了客户程序需要的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理 |
| 抽象状态（State）角色 | 定义一个接口，用以封装环境对象中的特定状态所对应的行为 |
| 具体状态（Concrete State）角色 | 实现抽象状态所对应的行为 |
3. 案例实现
对上述电梯的案例使用状态模式进行改进。类图如下：
代码如下：
// 抽象状态类
public abstract class LiftState {
// 定义一个环境角色，也就是封装状态的变化引起的功能变化
protected Context context;
public void setContext(Context context) {
this.context = context;
}
// 电梯开门动作
public abstract void open();
// 电梯关门动作
public abstract void close();
// 电梯运行动作
public abstract void run();
// 电梯停止动作
public abstract void stop();
}// 开启状态
public class OpeningState extends LiftState {
// 开启当然可以关闭了
@Override
public void open() {
System.out.println("电梯门开启...");
}
@Override
public void close() {
// 状态修改
super.context.setLiftState(Context.closingState);
// 动作委托为ClosingState来执行，也就是委托给了ClosingState子类执行这个动作
super.context.getLiftState().close();
}
// 电梯门不能开着就跑，这里什么也不做
@Override
public void run() {
// do nothing
}
// 开门状态已经是停止的了
@Override
public void stop() {
// do nothing
}
}// 运行状态
public class RunningState extends LiftState {
// 运行的时候开电梯门？电梯不会给你开的
@Override
public void open() {
// do nothing
}
// 电梯门肯定是关着的，这个动作不归我执行
@Override
public void close() {
// do nothing
}
// 这是在运行状态下要实现的方法
@Override
public void run() {
System.out.println("电梯正在运行...");
}
// 光运行不停止还有谁敢坐这个电梯？
@Override
public void stop() {
super.context.setLiftState(Context.stoppingState);
super.context.stop();
}
}// 停止状态
public class StoppingState extends LiftState {
// 停止状态，开门，那是要的！
@Override
public void open() {
// 状态修改
super.context.setLiftState(Context.openingState);
// 动作委托给OpeningState子类执行这个动作
super.context.getLiftState().open();
}
@Override
public void close() {
// 状态修改
super.context.setLiftState(Context.closingState);
// 动作委托给ClosingState子类执行这个动作
super.context.getLiftState().close();
}
// 停止状态再跑起来，正常的很
@Override
public void run() {
// 状态修改
super.context.setLiftState(Context.runningState);
// 动作委托给RunningState子类执行这个动作
super.context.getLiftState().run();
}
// 停止状态是怎么发生的呢？当然是停止方法执行了
@Override
public void stop() {
System.out.println("电梯停止了...");
}
}// 关闭状态
public class ClosingState extends LiftState {
@Override
// 电梯门关闭，这是关闭状态要实现的动作
public void close() {
System.out.println("电梯门关闭...");
}
// 电梯门关了再打开，这个允许
@Override
public void open() {
super.context.setLiftState(Context.openingState);
super.context.open();
}
// 电梯门关了就跑，这是再正常不过了
@Override
public void run() {
super.context.setLiftState(Context.runningState);
super.context.run();
}
// 电梯门关着，就可以停止
@Override
public void stop() {
super.context.setLiftState(Context.stoppingState);
super.context.stop();
}
}// 环境角色
public class Context {
// 定义出所有的电梯状态
public final static OpeningState openingState = new OpeningState(); // 开门状态，这时候电梯只能关闭
public final static ClosingState closingState = new ClosingState(); // 关闭状态，这时候电梯可以运行、停止和开门
public final static RunningState runningState = new RunningState(); // 运行状态，这时候电梯只能停止
public final static StoppingState stoppingState = new StoppingState(); // 停止状态，这时候电梯可以开门、运行
// 定义一个当前电梯状态
private LiftState liftState;
public LiftState getLiftState() {
return this.liftState;
}
public void setLiftState(LiftState liftState) {
// 当前环境改变
this.liftState = liftState;
// 把当前的环境通知到各个实现类中
this.liftState.setContext(this);
}
public void open() {
this.liftState.open();
}
public void close() {
this.liftState.close();
}
public void run() {
this.liftState.run();
}
public void stop() {
this.liftState.stop();
}
}// 测试类
public class Client {
public static void main(String[] args) {
Context context = new Context();
context.setLiftState(new ClosingState());
context.open();
context.close();
context.run();
context.stop();
}
}运行结果如下：
电梯门开启...
电梯门关闭...
电梯正在运行...
电梯停止了...注
对比改造前后可以发现，状态模式最大的变化是"状态自己有了行为"：原来的 switch-case 被拆散到 4 个状态类中，电梯做什么动作不再由一坨条件判断决定，而是由当前状态对象决定，状态切换（setLiftState）与动作执行（context.xxx()）交替进行，就完成了整个流程。
4. 优缺点
4.1 优点
- 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为；
- 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
4.2 缺点
- 状态模式的使用必然会增加系统类和对象的个数；
- 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱；
- 状态模式对"开闭原则"的支持并不太好。
提示
状态模式与策略模式的类图几乎一致，区分点在于意图：策略模式的客户端通常会主动指定用哪个策略，且策略之间相互独立；状态模式的状态切换由环境或状态对象内部自动完成，状态之间存在明确的流转关系（比如关门状态可以转运行状态）。判断"行为由谁决定"就能选对模式。
5. 使用场景
- 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式；
- 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。