1 概述

【例】通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。
类图如下：
image.png
代码如下：

  1. public interface ILift {
  2.     //电梯的4个状态
  3.     //开门状态
  4.     public final static int OPENING_STATE = 1;
  5.     //关门状态
  6.     public final static int CLOSING_STATE = 2;
  7.     //运行状态
  8.     public final static int RUNNING_STATE = 3;
  9.     //停止状态
  10.     public final static int STOPPING_STATE = 4;
  12.     //设置电梯的状态
  13.     public void setState(int state);
  15.     //电梯的动作
  16.     public void open();
  17.     public void close();
  18.     public void run();
  19.     public void stop();
  20. }
  22. public class Lift implements ILift {
  23.     private int state;
  25.     @Override
  26.     public void setState(int state) {
  27.         this.state = state;
  28.     }
  30.     //执行关门动作
  31.     @Override
  32.     public void close() {
  33.         switch (this.state) {
  34.             case OPENING_STATE:
  35.                 System.out.println("电梯关门了。。。");//只有开门状态可以关闭电梯门，可以对应电梯状态表来看
  36.                 this.setState(CLOSING_STATE);//关门之后电梯就是关闭状态了
  37.                 break;
  38.             case CLOSING_STATE:
  39.                 //do nothing //已经是关门状态，不能关门
  40.                 break;
  41.             case RUNNING_STATE:
  42.                 //do nothing //运行时电梯门是关着的，不能关门
  43.                 break;
  44.             case STOPPING_STATE:
  45.                 //do nothing //停止时电梯也是关着的，不能关门
  46.                 break;
  47.         }
  48.     }
  50.     //执行开门动作
  51.     @Override
  52.     public void open() {
  53.         switch (this.state) {
  54.             case OPENING_STATE://门已经开了，不能再开门了
  55.                 //do nothing
  56.                 break;
  57.             case CLOSING_STATE://关门状态，门打开:
  58.                 System.out.println("电梯门打开了。。。");
  59.                 this.setState(OPENING_STATE);
  60.                 break;
  61.             case RUNNING_STATE:
  62.                 //do nothing 运行时电梯不能开门
  63.                 break;
  64.             case STOPPING_STATE:
  65.                 System.out.println("电梯门开了。。。");//电梯停了，可以开门了
  66.                 this.setState(OPENING_STATE);
  67.                 break;
  68.         }
  69.     }
  71.     //执行运行动作
  72.     @Override
  73.     public void run() {
  74.         switch (this.state) {
  75.             case OPENING_STATE://电梯不能开着门就走
  76.                 //do nothing
  77.                 break;
  78.             case CLOSING_STATE://门关了，可以运行了
  79.                 System.out.println("电梯开始运行了。。。");
  80.                 this.setState(RUNNING_STATE);//现在是运行状态
  81.                 break;
  82.             case RUNNING_STATE:
  83.                 //do nothing 已经是运行状态了
  84.                 break;
  85.             case STOPPING_STATE:
  86.                 System.out.println("电梯开始运行了。。。");
  87.                 this.setState(RUNNING_STATE);
  88.                 break;
  89.         }
  90.     }
  92.     //执行停止动作
  93.     @Override
  94.     public void stop() {
  95.         switch (this.state) {
  96.             case OPENING_STATE: //开门的电梯已经是是停止的了(正常情况下)
  97.                 //do nothing
  98.                 break;
  99.             case CLOSING_STATE://关门时才可以停止
  100.                 System.out.println("电梯停止了。。。");
  101.                 this.setState(STOPPING_STATE);
  102.                 break;
  103.             case RUNNING_STATE://运行时当然可以停止了
  104.                 System.out.println("电梯停止了。。。");
  105.                 this.setState(STOPPING_STATE);
  106.                 break;
  107.             case STOPPING_STATE:
  108.                 //do nothing
  109.                 break;
  110.         }
  111.     }
  112. }
  114. public class Client {
  115.     public static void main(String[] args) {
  116.         Lift lift = new Lift();
  117.         lift.setState(ILift.STOPPING_STATE);//电梯是停止的
  118.         lift.open();//开门
  119.         lift.close();//关门
  120.         lift.run();//运行
  121.         lift.stop();//停止
  122.     }
  123. }

问题分析：

  • 使用了大量的switch…case这样的判断（if…else也是一样)，使程序的可阅读性变差。
  • 扩展性很差。如果新加了断电的状态，我们需要修改上面判断逻辑


定义：
对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

2 结构

状态模式包含以下主要角色。

  • 环境（Context）角色：也称为上下文，它定义了客户程序需要的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。
  • 抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为。
  • 具体状态（Concrete State）角色：实现抽象状态所对应的行为。


3 案例实现

对上述电梯的案例使用状态模式进行改进。类图如下：
image.png
代码如下：

  1. //抽象状态类
  2. public abstract class LiftState {
  3.     //定义一个环境角色，也就是封装状态的变化引起的功能变化
  4.     protected Context context;
  6.     public void setContext(Context context) {
  7.         this.context = context;
  8.     }
  10.     //电梯开门动作
  11.     public abstract void open();
  13.     //电梯关门动作
  14.     public abstract void close();
  16.     //电梯运行动作
  17.     public abstract void run();
  19.     //电梯停止动作
  20.     public abstract void stop();
  21. }
  23. //开启状态
  24. public class OpenningState extends LiftState {
  26.     //开启当然可以关闭了，我就想测试一下电梯门开关功能
  27.     @Override
  28.     public void open() {
  29.         System.out.println("电梯门开启...");
  30.     }
  32.     @Override
  33.     public void close() {
  34.         //状态修改
  35.         super.context.setLiftState(Context.closeingState);
  36.         //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
  37.         super.context.getLiftState().close();
  38.     }
  40.     //电梯门不能开着就跑，这里什么也不做
  41.     @Override
  42.     public void run() {
  43.         //do nothing
  44.     }
  46.     //开门状态已经是停止的了
  47.     @Override
  48.     public void stop() {
  49.         //do nothing
  50.     }
  51. }
  53. //运行状态
  54. public class RunningState extends LiftState {
  56.     //运行的时候开电梯门？你疯了！电梯不会给你开的
  57.     @Override
  58.     public void open() {
  59.         //do nothing
  60.     }
  62.     //电梯门关闭？这是肯定了
  63.     @Override
  64.     public void close() {//虽然可以关门，但这个动作不归我执行
  65.         //do nothing
  66.     }
  68.     //这是在运行状态下要实现的方法
  69.     @Override
  70.     public void run() {
  71.         System.out.println("电梯正在运行...");
  72.     }
  74.     //这个事绝对是合理的，光运行不停止还有谁敢做这个电梯？！估计只有上帝了
  75.     @Override
  76.     public void stop() {
  77.         super.context.setLiftState(Context.stoppingState);
  78.         super.context.stop();
  79.     }
  80. }
  82. //停止状态
  83. public class StoppingState extends LiftState {
  85.     //停止状态，开门，那是要的！
  86.     @Override
  87.     public void open() {
  88.         //状态修改
  89.         super.context.setLiftState(Context.openningState);
  90.         //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
  91.         super.context.getLiftState().open();
  92.     }
  94.     @Override
  95.     public void close() {//虽然可以关门，但这个动作不归我执行
  96.         //状态修改
  97.         super.context.setLiftState(Context.closeingState);
  98.         //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
  99.         super.context.getLiftState().close();
  100.     }
  102.     //停止状态再跑起来，正常的很
  103.     @Override
  104.     public void run() {
  105.         //状态修改
  106.         super.context.setLiftState(Context.runningState);
  107.         //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
  108.         super.context.getLiftState().run();
  109.     }
  111.     //停止状态是怎么发生的呢？当然是停止方法执行了
  112.     @Override
  113.     public void stop() {
  114.         System.out.println("电梯停止了...");
  115.     }
  116. }
  118. //关闭状态
  119. public class ClosingState extends LiftState {
  121.     @Override
  122.     //电梯门关闭，这是关闭状态要实现的动作
  123.     public void close() {
  124.         System.out.println("电梯门关闭...");
  125.     }
  127.     //电梯门关了再打开，逗你玩呢，那这个允许呀
  128.     @Override
  129.     public void open() {
  130.         super.context.setLiftState(Context.openningState);
  131.         super.context.open();
  132.     }
  135.     //电梯门关了就跑，这是再正常不过了
  136.     @Override
  137.     public void run() {
  138.         super.context.setLiftState(Context.runningState);
  139.         super.context.run();
  140.     }
  142.     //电梯门关着，我就不按楼层
  143.     @Override
  144.     public void stop() {
  145.         super.context.setLiftState(Context.stoppingState);
  146.         super.context.stop();
  147.     }
  148. }
  150. //环境角色
  151. public class Context {
  152.     //定义出所有的电梯状态
  153.     public final static OpenningState openningState = new OpenningState();//开门状态，这时候电梯只能关闭
  154.     public final static ClosingState closeingState = new ClosingState();//关闭状态，这时候电梯可以运行、停止和开门
  155.     public final static RunningState runningState = new RunningState();//运行状态，这时候电梯只能停止
  156.     public final static StoppingState stoppingState = new StoppingState();//停止状态，这时候电梯可以开门、运行
  159.     //定义一个当前电梯状态
  160.     private LiftState liftState;
  162.     public LiftState getLiftState() {
  163.         return this.liftState;
  164.     }
  166.     public void setLiftState(LiftState liftState) {
  167.         //当前环境改变
  168.         this.liftState = liftState;
  169.         //把当前的环境通知到各个实现类中
  170.         this.liftState.setContext(this);
  171.     }
  173.     public void open() {
  174.         this.liftState.open();
  175.     }
  177.     public void close() {
  178.         this.liftState.close();
  179.     }
  181.     public void run() {
  182.         this.liftState.run();
  183.     }
  185.     public void stop() {
  186.         this.liftState.stop();
  187.     }
  188. }
  190. //测试类
  191. public class Client {
  192.     public static void main(String[] args) {
  193.         Context context = new Context();
  194.         context.setLiftState(new ClosingState());
  196.         context.open();
  197.         context.close();
  198.         context.run();
  199.         context.stop();
  200.     }
  201. }

4 优缺点

1，优点：

  • 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
  • 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。

2，缺点：

  • 状态模式的使用必然会增加系统类和对象的个数。
  • 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
  • 状态模式对”开闭原则”的支持并不太好。


5 使用场景

  • 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
  • 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。