行为型模式-状态模式

已于 2023-01-26 10:20:41 修改
阅读量850 收藏
点赞数
分类专栏： 设计模式 文章标签： 状态模式
于 2023-01-26 10:05:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40742428/article/details/128764146
版权

1.概述

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

package com.itheima.pattern.state.before;

/**
 * @program: design-patterns
 * @ClassName ILift
 * @description: 电梯接口
 * @author: zhangzhifeng
 * @create: 2023-01-26 08:41
 * @Version 1.0
 **/
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();
}

package com.itheima.pattern.state.before;

/**
 * @program: design-patterns
 * @ClassName Lift
 * @description: 电梯类：ILift的子实现类
 * @author: 
 * @create: 2023-01-26 08:44
 * @Version 1.0
 **/
public class Lift implements ILift {

    // 声明一个记录当前电梯状态的常量
    private int state;

    public int getState() {
        return state;
    }

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

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

    @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 run() {
        switch (this.state) {
            case OPENING_STATE://电梯不能开着门就走
                //do nothing
                break;
            case CLOSING_STATE://门关了，可以运行了
            case STOPPING_STATE:
                System.out.println("电梯开始运行了。。。");
                this.setState(RUNNING_STATE);//现在是运行状态
                break;
            case RUNNING_STATE:
                //do nothing 已经是运行状态了
                break;
        }
    }

    @Override
    public void stop() {
        switch (this.state) {
            case OPENING_STATE: //开门的电梯已经是是停止的了(正常情况下)
                //do nothing
                break;
            case CLOSING_STATE://关门时才可以停止
            case RUNNING_STATE://运行时当然可以停止了
                System.out.println("电梯停止了。。。");
                this.setState(STOPPING_STATE);
                break;
            case STOPPING_STATE:
                //do nothing
                break;
        }
    }
}

package com.itheima.pattern.state.before;

/**
 * @program: design-patterns
 * @ClassName Client
 * @description: 测试类
 * @author: 
 * @create: 2023-01-26 08:51
 * @Version 1.0
 **/
public class Client {
    public static void main(String[] args) {
        // 创建电梯对象
        Lift lift = new Lift();
        // 设置当前电梯的状态
        lift.setState(ILift.OPENING_STATE);

        // 开门
        lift.open();

        lift.close();

        lift.run();
        
        lift.stop();
    }
}

问题分析：

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

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

2.结构

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

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

3.案例实现

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

package com.itheima.pattern.state.after;

/**
 * @program: design-patterns
 * @ClassName LiftState
 * @description: 抽象状态类
 * @author: 
 * @create: 2023-01-26 09:02
 * @Version 1.0
 **/
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();
}

package com.itheima.pattern.state.after;

/**
 * @program: design-patterns
 * @ClassName OpeningState
 * @description: 电梯关闭状态类
 * @author: 
 * @create: 2023-01-26 09:05
 * @Version 1.0
 **/
public class ClosingState extends LiftState {

    @Override
//电梯门关闭，这是关闭状态要实现的动作
    public void close() {
        System.out.println("电梯门关闭...");
    }

    //电梯门关了再打开，逗你玩呢，那这个允许呀
    @Override
    public void open() {
        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();
    }
}

package com.itheima.pattern.state.after;

/**
 * @program: design-patterns
 * @ClassName OpeningState
 * @description: 电梯开启状态类
 * @author: 
 * @create: 2023-01-26 09:05
 * @Version 1.0
 **/
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() {
        // 什么都不做
    }
}

package com.itheima.pattern.state.after;

/**
 * @program: design-patterns
 * @ClassName OpeningState
 * @description: 电梯运行状态类
 * @author: 
 * @create: 2023-01-26 09:05
 * @Version 1.0
 **/
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.STOPPING_STATE);
        super.context.stop();
    }
}

package com.itheima.pattern.state.after;

/**
 * @program: design-patterns
 * @ClassName OpeningState
 * @description: 电梯停止状态类
 * @author: 
 * @create: 2023-01-26 09:05
 * @Version 1.0
 **/
public class StoppingState extends LiftState {

    //停止状态，开门，那是要的！
    @Override
    public void open() {
        //状态修改
        super.context.setLiftState(Context.OPENING_STATE);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().open();
    }

    @Override
    public void close() {//虽然可以关门，但这个动作不归我执行
        //状态修改
        super.context.setLiftState(Context.CLOSING_STATE);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().close();
    }

    //停止状态再跑起来，正常的很
    @Override
    public void run() {
        //状态修改
        super.context.setLiftState(Context.RUNNING_STATE);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().run();
    }

    //停止状态是怎么发生的呢？当然是停止方法执行了
    @Override
    public void stop() {
        System.out.println("电梯停止了...");
    }
}

package com.itheima.pattern.state.after;

/**
 * @program: design-patterns
 * @ClassName Context
 * @description: 环境角色类
 * @author: 
 * @create: 2023-01-26 09:03
 * @Version 1.0
 **/
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();
    }
}

package com.itheima.pattern.state.after;

/**
 * @program: design-patterns
 * @ClassName Client
 * @description: 测试类
 * @author: 
 * @create: 2023-01-26 09:45
 * @Version 1.0
 **/
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();
    }
}

4.优缺点

  • 优点
    • 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
    • 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
  • 缺点
    • 状态模式的使用必然会增加系统类和对象的个数。
    • 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
    • 状态模式对"开闭原则"的支持并不太好。

5.使用场景

  • 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
  • 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。
行万里路，读万卷书
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++设计模式-行为型模式-状态模式
06-20
c++设计模式-行为型模式-状态模式；qt工程；c++简单源码； 状态（State）模式的定义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。
JAVA-设计模式-行为型模式-状态模式
08-10
JAVA-设计模式-行为型模式-状态模式
设计模式 - 行为型设计模式 - 状态模式（Java）
热门推荐
了解➔熟悉➔掌握➔精通
02-12 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net Definition Allow an object to alter its behavior when its internal state changes. The object will appear to change its clas...
设计模式-行为型模式-模板方法模式
帅帅气气的黑猫警长
11-19 3610
设计模式-行为型模式-模板方法模式
行为型模式-状态(state)
03-29 2757
状态允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类.
15设计模式-行为型模式-观察者模式
weixin_46643875的博客
08-09 2986
15设计模式-行为型模式-观察者模式
C++行为型模式-实现观察者模式
灰太狼的小秘密
09-01 6882
一、观察者模式基本概念 二、改进观察者模式 参考文献： 【1】
设计模式-状态模式
m0_51810668的博客
06-13 1847
设计模式-状态模式
设计模式行为型——状态模式
tszc95的博客
08-07 2323
状态模式（State Pattern）属于行为型设计模，也叫作状态机模式（StateMachine Pattern），对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。状态模式中类的行为是由状态决定的，在不同的状态下有不同的行为。其意图是让一个对象在其内部改变的时候，行为也随之改变。状态模式的核心是状态与行为绑定，不同的状态对应不同的行为。
java设计模式-状态模式
张钰杰杰杰杰杰的博客
04-24 2281
状态模式介绍： 当一个对象在内在状态改变时，允许改变起行为，这个对象看起来像是改变了其类。 状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂的情况。把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简化。 简例 工作状态－分类板 package com.example.designmode.statepattern; import lombok.Data; /** * <h3>design-mode</h3> * <p>工作状态－分
设计模式：行为型-状态模式
轻松的小希
04-11 1428
目录第一章 状态模式介绍第二章 状态模式实现2.1、环境类2.2、抽象状态类2.3、具体状态类2.4、测试类第三章 状态模式应用3.1、环境类3.2、抽象状态类3.3、具体状态类3.4、测试类 项目地址：https://gitee.com/caochenlei/design-pattern 第一章 状态模式介绍 状态模式的介绍： 在软件开发过程中，应用程序中的部分对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。当有状态的对象与
Android 设计模式--状态模式
zenmela2011的专栏
08-24 1229
1.状态模式 状态模式State Pattern，是十一大行为型设计模式之一。 状态模式指的是当一个对象的内在状态改变时，其行为也随之改变。即状态模式中的行为是由状态来决定的，不同的状态下有不同的行为。 用一句话来表述，状态模式把对象的行为包装在不同的状态对象里，每一个状态对象都有一个共同的抽象状态基类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。 状态模式和策略模式的机构几乎完全一样，但它们的目的、本质却完全不一样。状态模式的行为是平行的，不可替换的，但策略模式的行为是彼此
设计模式-状态模式.pdf
05-16
状态模式（State Pattern）是一种行为设计模式，它允许对象在其内部状态改变时改变其行为，从而使对象看起来像改变了其类。这种模式的主要目的是将对象的状态作为独立的类来管理，从而简化了条件逻辑并提高了代码的...
java常用设计模式-状态模式
08-28
状态模式是一种行为型设计模式，它允许对象在内部状态改变时改变它的行为。状态模式将状态封装成独立的类，并将请求委托给当前状态对象，从而实现状态的切换和状态行为的变化。 状态模式的优点： * 可以将状态和...
c++设计模式-行为型模式-观察者模式
06-21
c++设计模式-行为型模式-观察者模式；qt工程；c++简单源码； 观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式...
基于OSS前端直传的分片上传以及断点续传
最新发布
一名努力学习前端的大三学生
07-25 1094
基于OSS前端直传的分片上传以及断点续传
12 前端工程化
ever__ever的博客
07-24 1173
前端工程化
BFF架构：优化前后端协作设计模式
刻痕
07-24 1221
BFF的出现为前端应用提供一个对业务服务的聚合API，减少复杂服务的调用链，让前端聚焦处理所需的数据，后端专注开发底层服务能力。每个人对一个技术认知是不同的。设计API时要考虑不同设备应用的需求，也就是为不同的设备提供不同的API，虽然他们可能会实现相同的工鞥，但因为不同系统、业务组、设备的特殊性，他们对服务端的API访问会各有特点，需要区别处理。BFF是在传统客户端和服务API之间的额外处理服务，对比前端发起的多个请求，中间层服务转发处理相对来说会有微小的服务延迟，但同时也会减少前端逻辑处理时间。
C++20之设计模式：状态模式
weixin_51332735的博客
07-25 1392
首先，这是值得强调的Boost.MSM是Boost中两种状态机实现之一，另一种是。我很确定还有很多其他的状态机实现。其次，状态机的功能远不止这些。例如，许多库支持分层状态机的思想:例如，一个生病(Sick)的状态可以包含许多不同的子状态，如流感(Flu)或水痘(Chickenpox)。如果你在处于感染流感的状态，你也同时处于生病的状态。最后，有必要再次强调现代状态机与状态设计模式的原始形式之间的差异。重复api的存在(例如)以及自删除的存在在我的书中是明确的代码气味。
"day05设计模式状态观察者备忘录迭代器中介者访问者行为型模式-状态模式概述
在其中，状态模式是一种常见的行为型模式，用于描述对象的状态转换及处理方式。在状态模式中，一个对象可以在不同的状态之间进行转换，同时在不同的状态下可以有不同的行为。 举例来说，我们可以通过按钮来控制一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值