【设计模式2022】第十八章 状态模式

已于 2022-05-04 19:10:51 修改
阅读量502 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
于 2022-05-03 11:07:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45593575/article/details/124544874
版权

【设计模式2022】第十八章 状态模式

文章目录

一、概述

通过按钮来控制一个电梯的状态，一个电梯有开门状态、关门状态、停止状态、运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行状态，就不能进行开门操作。类图如下：
在这里插入图片描述
电梯接口：

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

电梯类：

public class Lift implements ILift{
    //记录当前电梯的状态
    private int state;

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

    @Override
    public void open() {
        switch (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 close() {
        switch (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 run() {
        switch (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;
        }
    }
}

Client 测试类：

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 语句，程序的可读性很差
  • 扩展性很差，如果新加了断电状态，我们需要修改上面的所有判断逻辑

为了解决上述问题我们可以使用状态模式，状态模式的定义：
对有状态的对象，把复杂的判断逻辑提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为

二、结构

状态模式具有以下主要角色：

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

三、实现

对上述电梯的哪里使用状态模式进行改进。类图如下：
在这里插入图片描述
状态抽象类：

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 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 OpeningState extends LiftState {
    @Override
    public void open() {
        System.out.println("电梯开启");
    }

    @Override
    public void close() {
        //修改状态
        super.context.setLiftState(Context.CLOSING_STATE);
        //调用当前状态中的 context 中的 close 方法
        super.context.close();
    }

    @Override
    public void run() {
        //什么都不做
    }

    @Override
    public void stop() {
        //什么都不做
    }
}

电梯关闭状态：

public class ClosingState extends LiftState {
    @Override
    public void open() {
        System.out.println("电梯门关闭");
    }

    @Override
    public void close() {
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.open();
    }

    @Override
    public void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.run();
    }

    @Override
    public void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.stop();
    }
}

电梯运行状态：

public class RunningState extends LiftState {
    @Override
    public void open() {
        //什么都不做
    }

    @Override
    public void close() {
        //什么都不做
    }

    @Override
    public void run() {
        System.out.println("电梯正在运行");
    }

    @Override
    public void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.stop();
    }
}

电梯停止状态：

public class StoppingState extends LiftState {
    @Override
    public void open() {
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.getLiftState().open();
    }

    @Override
    public void close() {
        super.context.setLiftState(Context.CLOSING_STATE);
        super.context.getLiftState().close();
    }

    @Override
    public void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.getLiftState().run();
    }

    @Override
    public void stop() {
        System.out.println("电梯停止了");
    }
}

Client 测试类：

public class Client {
    public static void main(String[] args) {
        //创建环境角色对象
        Context context = new Context();
        //设置当前电梯状态
        context.setLiftState(new RunningState());

        context.open();
        context.close();
        context.run();
        context.stop();
    }
}

四、分析

1.优点

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

2.缺点

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

3.使用场景

  • 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑 使用状态模式
  • 一个操作中含有庞大的分支结构，并且这些分治决定于对象的状态时
313YPHU3
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
设计模式PPT.rar
08-27
12第十二讲代理模式 13第十三讲外观模式 14第十四讲组合模式 15第十五讲桥接模式 16第十六讲适配器模式 17第十七讲解释器模式 18第十八讲中介者模式 19第十九讲职责链模式 20第二十讲迭代模式 21第二十一讲模板方法...
java设计模式
05-08
第18章 策略模式 18.1 刘备江东娶妻，赵云他容易吗 18.2 策略模式的定义 18.3 策略模式的应用 18.3.1 策略模式的优点 18.3.2 策略模式的缺点 18.3.3 策略模式的应用 18.3.4 策略模式的注意事项 18.4 策略模式的扩展 ...
状态模式（State Pattern）
qq_21344887的博客
10-11 151
在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。 在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。 优点： 封装了转换规则。 枚举可能的状态，在枚举状态之前需要确定状态种类。 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。 允许...
状态模式
qq_39368007的博客
02-25 299
状态模式 概述 【例】通过按钮来控制一个电梯的状态， 一个电梯有开门状态，关门状态，停止状态，运行状态。 每一种状态改变，都有可能要根据其他状态来更新处理。 例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。 类图如下： ILift.java package com.itheima.pattern.state.before; /** * @version v1.0 * @ClassName: ILift * @Descripti
设计模式之状态模式详解
glass__sky的博客
06-10 3146
【例】通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。...
23中设计模式之_状态模式
Lighthouse
03-09 849
23中设计模式之_状态模式前言状态模式听起来有点像策略模式，根据不同的状态执行不同的程序代码，真正去理解的时候，才知道另有一片天地。引入现在城市发展很快，百万级人口的城市一堆一堆的，那其中有两个东西的发明在城市的发展中起到非 常重要的作用：一个是汽车，一个呢是…，猜猜看，是什么？是电梯！汽车让城市可以横向扩展，电梯让 城市可以纵向延伸，向空中伸展。汽车对城市的发展我们就不说了，电梯，你想想看，如
设计模式--状态模式
evior
08-28 132
场景一 描述：现在城市发展很快，百万级人口的城市一堆一堆的，那其中有两个东西的发明在城市的发展中起到非常重要的作用：一个是汽车，一个呢是...，猜猜看，是什么？是电梯！汽车让城市可以横向扩展，电梯让城市可以纵向延伸，向空中伸展。汽车对城市的发展我们就不说了，电梯，你想想看，如果没有电梯，每天你需要爬10 层楼梯，你是不是会崩溃掉？建筑师设计了一个没有电梯的建筑，那投资家肯定不愿意投资，那也是建筑...
设计模式课程每章ppt(共27章).zip
03-29
├── 第18章_命令模式.ppt ├── 第19章_解释器模式.ppt ├── 第20章_迭代器模式.ppt ├── 第21章_中介者模式.ppt ├── 第22章_备忘录模式.ppt ├── 第23章_观察者模式.ppt ├── 第24章_状态模式.ppt ...
研磨设计模式(完整带书签).part2.pdf
06-13
第18章 状态模式（State） 第19章 备忘录模式（Memento） 第20章 享元模式（Flyweight） 第21章 解释器模式（Interpreter） 第22章 装饰模式（Decorator） 第23章 职责链模式（Chain of Responsibility） 第24...
设计模式-7种开发语言（C#、JAVA、JavaScript、C++、Python、Go、PHP）.pdf
10-30
24种设计模式的入门，整合7种开发语言的...第十八节 中介者模式 第十九节 备忘录模式 第二十节 状态模式 第二十一节 访问者模式 第二十二节 原型模式 第二十三节 享元模式 第二十四节 责任链模式 第二十五节 解释器模式
设计模式之状态模式
二木成林
07-15 159
概述 在软件开发过程中，应用程序中的部分对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。当有状态的对象与外部事件产生互动时，其内部状态就会发生改变，从而使其行为也发生改变。如人都有高兴和伤心的时候，不同的情绪有不同的行为，当然外界也会影响其情绪变化。 对这种有状态的对象编程，传统的解决方案是：将这些所有可能发生的情况全都考虑到，然后使用 if-else 或 switch-case 语句来做状态判断，再进行不同情况的处理。但是显然
状态模式【State Pattern】
美丽心情
02-05 371
现在城市发展很快，百万级人口的城市一堆一堆的，那其中有两个东西的发明在城市的发展中起到非常重要的作用：一个是汽车，一个呢是...，猜猜看，是什么？是电梯！汽车让城市可以横向扩展，电梯让城市可以纵向延伸，向空中伸展。汽车对城市的发展我们就不说了，电梯，你想想看，如果没有电梯，每天你需要爬10 层楼梯，你是不是会崩溃掉？建筑师设计了一个没有电梯的建筑，那投资家肯定不愿意投资，那也是建筑师的耻辱呀，今天
C++11 设计模式6. 建造者模式，也叫做生成器模式
hunandede的博客
04-29 475
建造者模式（也被成为⽣成器模式），是⼀种创建型设计模式，软件开发过程中有的时候需要创建很复杂的对象，⽽建造者模式的主要思想是将对象的构建过程分为多个步骤，并为每个步骤定义⼀个抽象的接⼝。，构建过程相对复杂，⽽我们使⽤建造者模式将计算机的构建过程封装在⼀个具体的建造者类中，⽽指导者类则负责指导构建的步骤和顺序。每个具体的建造者类可以负责构建不同型号或配置的计算机，客户端代码可以通过选择不同的建造者来创建不同类型的计算机，这样就可以根据需要构建不同表示的复杂对象，更加灵活。
设计模式（十）：装饰者模式
wenqi1992的博客
04-29 380
装饰者模式的介绍
c++设计模式
qq_27344469的博客
04-28 229
uniontech: 赵良云问题: 23种设计模式，你知道多少....，KL:大话数据结构、大话设计模式、人人都是产品经理，编程之美。ChinaSoft:数据结构，类模板与模板类，回调函数。加班复加班，加班何其多，事事待加班，项目成蹉跎；单一职责原则、开放封闭原则、依赖倒转原则。业务逻辑与界面分开，让它们之间的耦合度下降。面向对象思想(维护性 扩展性 复用性)Hollysys:深拷贝与浅拷贝。编程是一门技术，更加是一门艺术。这是看到的一篇博主写的文章，努力一次把事情做好。
Python如何实现抽象工厂模式
一点
04-30 953
在软件工程中，抽象工厂模式（Abstract Factory Pattern）是一种设计模式，用于在运行时创建一组相关或相互依赖的对象，而不需要指定它们的具体类。这种模式非常适合用于管理系统中对象的创建，同时保持这些对象之间的一致性和隔离性。抽象工厂模式涉及以下几个关键概念：抽象工厂（Abstract Factory）：提供一个创建一系列相关或依赖对象的接口，而不需要指定具体类。具体工厂（Concrete Factory）：实现抽象工厂接口，生产具体的产品对象。
Java 设计模式（行为型）
心若有所向往，何惧道阻且长。
04-28 1172
Java 设计模式（行为型）
设计模式的原则与分类
最新发布
孟孟的博客
04-30 235
单一职责原则是接口隔离原则的基础，单一职责原则注重职责的划分，从职责角度进行类和接口的划分；迪米特法则 又叫做最少知道原则，一个类对于其他类知道得越少越好，简单来说就是只暴露方法入口，而实现细节不需要暴露给调用者。如果要修改一个功能，不是直接进行内部的代码修改，而是使用扩展的方式进行。结构型模式，更加注重类或对象的结合方式，将类或对象进行结合，形成一个更大的结构，在该结构下，不同的组件扮演不同的角色。一个类只需要负责一种职责即可，一个类发生变化的原因，必然是所负责的职责发生变化。
Java 设计模式（结构型）
心若有所向往，何惧道阻且长。
04-29 1058
Java 设计模式（结构型）
java设计模式-面向对象
09-06
- *1* [计算机后端-Java-Java核心基础-第15章 面向对象07 14. 设计模式与单例设计模式.avi](https://download.csdn.net/download/programxh/85435560)[target="_blank" data-report-click={"spm":"1018.2226.3001....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

313YPHU3

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值