AI 助理
备案控制台
开发者社区 人工智能 文章 正文

《设计模式详解》行为型模式 - 状态模式

2022-05-25 224
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 行为型模式 - 状态模式

行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象无法单独完成的任务，它涉及算法与对象间职责的分配。行为型模式分为类行为模式和对象行为模式：

  • 类行为模式：采用继承机制来在类间分派行为
  • 对象行为模式：采用组合或聚合在对象间分配行为

由于组合关系或聚合关系比继承关系耦合度低，满足 “合成复用原则”，所以对象行为模式比类行为模式具有更大的灵活性。

行为型模式分为：

  • 模板方法模式
  • 策略模式
  • 命令模式
  • 职责链模式
  • ==状态模式==
  • 观察者模式
  • 中介者模式
  • 迭代器模式
  • 访问者模式
  • 备忘录模式
  • 解释器模式

以上 11 种行为型模式，除了模板方法模式和解释器模式是类行为型模式，其他的全部属于对象行为型模式。

6.5 状态模式

6.5.1 反例

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

在这里插入图片描述

/**
 * 电梯接口
 */
public interface ILift {
    // 定义四个电梯状态的常量
    int OPENING_STATE = 1;
    int CLOSING_STATE = 2;
    int RUNNING_STATE = 3;
    int STOPPING_STATE = 4;
    // 设置电梯状态的功能
    void setState(int state);
    // 电梯操作功能
    void open();
    void close();
    void run();
    void stop();
}
/**
 * 电梯类(ILift的子实现类)
 */
public class Lift implements ILift {
    // 声明一个记录当前电梯的状态
    private int state;

    public void setState(int state) {
        this.state = state;
    }

    public void open() {
        switch (state) {
            case OPENING_STATE:
                // 什么事都不做
                break;
            case CLOSING_STATE:
                System.out.println("电梯打开了...");
                // 设置当前电梯状态为开启状态
                setState(OPENING_STATE);
                break;
            case STOPPING_STATE:
                System.out.println("电梯打开了...");
                // 设置当前电梯状态为开启状态
                setState(OPENING_STATE);
                break;
            case RUNNING_STATE:
                // 什么事都不做
                break;
        }
    }

    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;
        }
    }

    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;
        }
    }

    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.RUNNING_STATE);
        // 打开
        lift.open();
        lift.close();
        lift.run();
        lift.stop();
    }
}

问题分析：

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

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

6.5.2 结构

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

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

6.5.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 {
    // 当前状态要执行的方法
    public void open() {
        System.out.println("电梯开启。。。");
    }
    public void close() {
        // 修改状态
        super.context.setLiftState(Context.CLOSING_STATE);
        // 修改环境
        super.context.close();
    }
    public void run() {}
    public void stop() {}
}

/**
 * 电梯关闭状态类
 */
public class ClosingState extends LiftState {
    // 当前状态要执行的方法
    public void close() {
        System.out.println("电梯门关闭...");
    }
    // 关闭 -> 开启
    public void open() {
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.open();
    }
    // 关闭 -> 运行
    public void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.run();
    }
    // 关闭 -> 停止
    public void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.stop();
    }
}

/**
 * 电梯运行状态类
 */
public class RunningState extends LiftState {
    // 当前状态要执行的方法
    public void run() {
        System.out.println("电梯正在运行...");
    }
    // 运行时无法开门
    @Override
    public void open() {}
    // 运行时门是关的
    @Override
    public void close() {}
    // 运行 -> 停止
    @Override
    public void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.stop();
    }
}

/**
 * 电梯停止状态类
 */
public class StoppingState extends LiftState {
    // 当前状态要执行的方法
    public void stop() {
        System.out.println("电梯停止了...");
    }
    // 停止 -> 开门（委托给ClosingState子类执行）
    public void open() {
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.getLiftState().open();
    }
    // 停止 -> 关门（委托给ClosingState子类执行）
    public void close() {
        super.context.setLiftState(Context.CLOSING_STATE);
        super.context.getLiftState().close();
    }
    // 停止 -> 运行（委托给ClosingState子类执行）
    public void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.getLiftState().run();
    }
}

环境角色类：

public class Context {
    // 定义对应状态对象的常量
    public final static OpeningState OPENING_STATE = new OpeningState();
    public final static ClosingState CLOSING_STATE = new ClosingState();
    public final static RunningState RUNNING_STATE = new RunningState();
    public final static StoppingState STOPPING_STATE = new StoppingState();

    // 定义一个当前电梯状态变量
    private LiftState liftState;
    public LiftState getLiftState() {
        return liftState;
    }

    // 设置当前状态对象
    public void setLiftState(LiftState liftState) {
        this.liftState = liftState;
        // 设置当前状态对象中的Context对象
        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.run();
        context.close();
        context.stop();
    }
}

6.5.4 优缺点

优点：

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

缺点：

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

6.5.5 使用场景

  • 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
  • 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。
文章标签：
算法
设计模式
关键词：
设计模式行为型模式
设计模式状态模式
设计模式行为型模式状态模式
萌宅鹿同学
目录
相关文章
全干程序员demo
|
1月前
|
设计模式 监控 算法
Java设计模式梳理：行为型模式（策略，观察者等）
本文详细介绍了Java设计模式中的行为型模式，包括策略模式、观察者模式、责任链模式、模板方法模式和状态模式。通过具体示例代码，深入浅出地讲解了每种模式的应用场景与实现方式。例如，策略模式通过定义一系列算法让客户端在运行时选择所需算法；观察者模式则让多个观察者对象同时监听某一个主题对象，实现松耦合的消息传递机制。此外，还探讨了这些模式与实际开发中的联系，帮助读者更好地理解和应用设计模式，提升代码质量。
全干程序员demo
65 0
Java设计模式梳理：行为型模式（策略，观察者等）
艾利克斯冰
|
2月前
|
设计模式 Java 测试技术
Java设计模式-状态模式（18）
Java设计模式-状态模式（18）
艾利克斯冰
43 0
热爱技术的小郑
|
3月前
|
设计模式 算法 Java
【十六】设计模式~~~行为型模式~~~策略模式（Java）
文章详细介绍了策略模式（Strategy Pattern），这是一种对象行为型模式，用于定义一系列算法，将每个算法封装起来，并使它们可以相互替换。策略模式让算法独立于使用它的客户而变化，提高了系统的灵活性和可扩展性。通过电影院售票系统中不同类型用户的打折策略案例，展示了策略模式的动机、定义、结构、优点、缺点以及适用场景，并提供了Java代码实现和测试结果。
热爱技术的小郑
67 0
【十六】设计模式~~~行为型模式~~~策略模式（Java）
热爱技术的小郑
|
3月前
|
设计模式 网络协议 Java
【十五】设计模式~~~行为型模式~~~状态模式（Java）
文章详细介绍了状态模式（State Pattern），这是一种对象行为型模式，用于处理对象在其内部状态改变时的行为变化。文中通过案例分析，如银行账户状态管理和屏幕放大镜工具，展示了状态模式的应用场景和设计方法。文章阐述了状态模式的动机、定义、结构、优点、缺点以及适用情况，并提供了Java代码实现和测试结果。状态模式通过将对象的状态和行为封装在独立的状态类中，提高了系统的可扩展性和可维护性。
热爱技术的小郑
69 0
【十五】设计模式~~~行为型模式~~~状态模式（Java）
热爱技术的小郑
|
3月前
|
设计模式 存储 前端开发
【十四】设计模式~~~行为型模式~~~观察者模式（Java）
文章详细介绍了观察者模式（Observer Pattern），这是一种对象行为型模式，用于建立对象之间的一对多依赖关系。当一个对象状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。文中通过交通信号灯与汽车的案例以及多人联机对战游戏的设计方案，阐述了观察者模式的动机和应用场景。接着，文章介绍了观察者模式的结构、角色、优点、缺点以及适用情况，并通过代码示例展示了如何在Java中实现观察者模式。此外，还探讨了观察者模式在MVC架构中的应用以及Java中对观察者模式的支持。
热爱技术的小郑
55 0
【十四】设计模式~~~行为型模式~~~观察者模式（Java）
热爱技术的小郑
|
3月前
|
设计模式 前端开发 Java
【十三】设计模式~~~行为型模式~~~中介者模式（Java）
文章详细介绍了中介者模式（Mediator Pattern），这是一种对象行为型模式，用于封装一系列对象的交互，降低系统耦合度，并简化对象之间的交互关系。通过案例分析、结构图、时序图和代码示例，文章展示了中介者模式的组成部分、实现方式和应用场景，并讨论了其优点、缺点和适用情况。
热爱技术的小郑
35 0
【十三】设计模式~~~行为型模式~~~中介者模式（Java）
花酒锄作田
|
3月前
|
设计模式 安全 Go
[设计模式]行为型模式-观察者模式
[设计模式]行为型模式-观察者模式
花酒锄作田
38 1
热爱技术的小郑
|
3月前
|
设计模式 存储 Java
【十二】设计模式~~~行为型模式~~~命令模式（Java）
文章详细介绍了命令模式（Command Pattern），这是一种对象行为型模式，用于将请求封装成对象，实现请求发送者与接收者的解耦，从而降低系统耦合度、提高灵活性，并支持命令的排队、记录、撤销和恢复操作。通过案例分析、结构图、时序图和代码示例，文章展示了命令模式的组成部分、实现方式和应用场景，并讨论了其优点、缺点和适用情况。
热爱技术的小郑
53 0
花酒锄作田
|
3月前
|
设计模式 算法 测试技术
[设计模式]行为型模式-策略模式
[设计模式]行为型模式-策略模式
花酒锄作田
39 0
朝阳39
|
4月前
|
设计模式 JavaScript Go
js设计模式【详解】—— 状态模式
js设计模式【详解】—— 状态模式
朝阳39
80 7

热门文章

最新文章

  • 1
    3、Python与设计模式--建造者模式
  • 2
    设计模式--组合模式
  • 3
    设计模式之美：Command（命令）
  • 4
    极速理解设计模式系列：4.原型模式(Prototype Pattern)
  • 5
    设计模式[11]-Visitor
  • 6
    云计算设计模式（十九）——运行重构模式
  • 7
    深入浅出单实例Singleton设计模式
  • 8
    MapReduce设计模式学习
  • 9
    学习设计模式之单例模式
  • 10
    [浪子学编程][MS Enterprise Library]ObjectBuilder之设计模式(一)：策略模式
  • 1
    C++一分钟之-设计模式：工厂模式与抽象工厂
    43
  • 2
    《手把手教你》系列基础篇（九十四）-java+ selenium自动化测试-框架设计基础-POM设计模式实现-下篇（详解教程）
    50
  • 3
    C++一分钟之-C++中的设计模式：单例模式
    58
  • 4
    《手把手教你》系列基础篇（九十三）-java+ selenium自动化测试-框架设计基础-POM设计模式实现-上篇（详解教程）
    38
  • 5
    《手把手教你》系列基础篇（九十二）-java+ selenium自动化测试-框架设计基础-POM设计模式简介（详解教程）
    63
  • 6
    Java面试题：结合设计模式与并发工具包实现高效缓存；多线程与内存管理优化实践；并发框架与设计模式在复杂系统中的应用
    58
  • 7
    Java面试题：设计模式在并发编程中的创新应用，Java内存管理与多线程工具类的综合应用，Java并发工具包与并发框架的创新应用
    42
  • 8
    Java面试题：如何使用设计模式优化多线程环境下的资源管理？Java内存模型与并发工具类的协同工作，描述ForkJoinPool的工作机制，并解释其在并行计算中的优势。如何根据任务特性调整线程池参数
    50
  • 9
    Java面试题：请列举三种常用的设计模式，并分别给出在Java中的应用场景？请分析Java内存管理中的主要问题，并提出相应的优化策略？请简述Java多线程编程中的常见问题，并给出解决方案
    110
  • 10
    Java面试题：设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题，Java内存模型定义了线程如何与内存交互，包括原子性、可见性、有序性，并发框架提供了更高层次的并发任务处理能力
    78

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)