• 设计模式之状态模式

    1 概述

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

    类图如下：

    代码如下：

    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;
    11.  
    12.     //设置电梯的状态
    13.     public void setState(int state);
    14.  
    15.     //电梯的动作
    16.     public void open();
    17.     public void close();
    18.     public void run();
    19.     public void stop();
    20. }
    21.  
    22. public class Lift implements ILift {
    23.     private int state;
    24.  
    25.     @Override
    26.     public void setState(int state) {
    27.         this.state = state;
    28.     }
    29.  
    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.     }
    49.  
    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.     }
    70.  
    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.     }
    91.  
    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. }
    113.  
    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. }

    问题分析：

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

    为了解决这些问题，我们可以使用状态模式，在状态模式中，我们将对象在每一个状态下的行为和状态转移语句封装在一个个状态类中，通过这些状态类来分散冗长的条件转移语句，让系统具有更好的灵活性和可扩展性，状态模式可以在一定程度上解决上述问题。 

    也就是说 状态模式用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题。当系统中某个对象存在多个状态，这些状态之间可以进行转换，而且对象在不同状态下行为不相同时可以使用状态模式。

    状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象状态可以灵活变化，对于客户端而言，无须关心对象状态的转换以及对象所处的当前状态，无论对于何种状态的对象，客户端都可以一致处理。

    **基于与策略模式相同的 考虑，**首先将以上的类中每个状态的功能单独封装在一个类中。这样，就得到一个和策略模式相 同结构的类的结构体，称为状态模式。

    状态模式定义：

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

    结构

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

    1. 环境（Context）角色：也叫环境类， 又称为上下文类，它是拥有多种状态的对象。由于环境类的状态存在多样性且在不同状态下对象的行为有所不同，因此将状态独立出去形成单独的状态类。在环境类中维护一个抽象状态类State的实例，这个实例定义当前状态，在具体实现时，它是一个State子类的对象。

    2. 环境类实际上是真正拥有状态的对象，我们只是将环境类中与状态有关的代码提取出来封装到专门的状态类中。

    3. 抽象状态（State）角色： 它用于定义一个接口以封装与环境类的一个特定状态相关的行为，在抽象状态类中声明了各种不同状态对应的方法，而在其子类中实现类这些方法，由于不同状态下对象的行为可能不同，因此在不同子类中方法的实现可能存在不同，相同的方法可以写在抽象状态类中。
    4. 具体状态（Concrete State）角色： 它是抽象状态类的子类，每一个子类实现一个与环境类的一个状态相关的行为，每一个具体状态类对应环境的一个具体状态，不同的具体状态类其行为有所不同。
    5. 在状态模式中，我们将对象在不同状态下的行为封装到不同的状态类中，为了让系统具有更好的灵活性和可扩展性，同时对各状态下的共有行为进行封装，我们需要对状态进行抽象，引入了抽象状态类角色 。

     案例实现

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

    代码如下：

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

    状态模式将一个对象在不同状态下的不同行为封装在一个个状态类中，通过设置不同的状态对象可以让环境对象拥有不同的行为，而状态转换的细节对于客户端而言是透明的，方便了客户端的使用。在实际开发中，状态模式具有较高的使用频率，在工作流和游戏开发中状态模式都得到了广泛的应用，例如公文状态的转换、游戏中角色的升级等。

    优点：

    1. 封装了状态的转换规则，在状态模式中可以将状态的转换代码封装在环境类或者具体状态类中，可以对状态转换代码进行集中管理，而不是分散在一个个业务方法中。
    2. 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
    3. 可以****让多个环境对象共享一个状态对象****，从而减少系统中对象的个数。

    缺点：

    1. 状态模式的使用必然会增加系统类和对象的个数。
    2. 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
    3. 状态模式对"开闭原则"的支持并不太好。 增加新的状态类需要修改那些负责状态转换的源代码，否则无法转换到新增状态；而且修改某个状态类的行为也需修改对应类的源代码。

    使用场景

    1. 对象的行为依赖于它的状态（如某些属性值），状态的改变将导致行为的变化。
    2. 在代码中包含大量与对象状态有关的条件语句，这些条件语句的出现，会导致代码的可维护性和灵活性变差，不能方便地增加和删除状态，并且导致客户类与类库之间的耦合增强。

     

    策略模式和状态模式的区别
    策略模式用来处理一组具有相同目的但是实现方法不同的算法，这些算法方案之间一般来 说没有状态变迁，并且用户总是从几个算法中间选取一个。例如，以不同的格式保存文件，以不 同的算法压缩文件 以不同的算法排序，以不同的格式绘制同样数据的图形，以不同的方法显示 信息 等等。

    状态模式则有所不同，它实现的一个概念可以叫做动态继承，也就是继承的（ 代表一个状 态）子类都可以发生变化。状态的变化可以由一个状态迁移图表示。在实现中，如果状态的变 化由状态类完成，则在整个变化过程中某些状态之间需要插入一个新的状态或者状态的顺序之 间发生变化, 客户程序是根本不用改变的，即对客户是不可见的。

    一般地说，使用状态模式要比使用策略模式在设计与实现方面会更加复杂一些，原因是用户 需要仔细地考虑由谁负责状态转换问题，是由 Context 类负责还是由状态类的超类负责 还是由 状态类的子类负责等。

  • 相关阅读:
    XCTF1-web easyupload
    java动漫电影网站管理系统ssm
    Web前端项目-页面动态背景【附完整源码】
    01 初识FPGA
    Kafka3.0.0版本——消费者（独立消费者消费某一个主题数据案例__订阅主题）
    Java中Integer.parseInt()方法最全解析
    k8s一些难懂的技术点（1）
    【图像变换】基于matlab实现HSI和RGB域图像转换附matlab代码
    Python、设计原则和设计模式 更新中
    git回退到某个版本
  • 原文地址：https://blog.csdn.net/weixin_40501652/article/details/137222545