【软考】设计模式之状态模式

已于 2024-09-05 15:05:38 修改
阅读量753 收藏 3
点赞数 3
分类专栏： 软考 文章标签： 设计模式 软考
于 2024-03-26 13:42:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32088869/article/details/137005117
版权
本文介绍了状态模式在Java中的应用，通过非状态模式的电梯控制例子，对比并阐述了如何通过状态模式简化状态判断，提高代码可读性和扩展性。同时，详细展示了状态模式的结构和实现，包括抽象状态、具体状态以及上下文类的运用。
摘要由CSDN通过智能技术生成

目录

1. 说明
  • 1.允许一个对象在其内部状态改变时改变它的行为。
  • 2.对象看起来似乎修改了它的类。
  • 3.对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。
2. 应用场景
  • 1.一个对象的行为决定于它的状态，并且它必须在运行时刻根据状态改变它的行为。
  • 2.一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。这个状态常用一个或多个枚举常量表示。通常，有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这使得开发者可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其他对象独立变化。
3. 结构图

在这里插入图片描述

4. 构成
  • 1.环境角色：Context（上下文）定义客户端感兴趣的接口；维护一个ConcreteState子类的实例，这个实例定义当前状态
  • 2.抽象状态角色：State（状态）定义一个接口以封装与Context的一个特定状态相关的行为
  • 3.具体状态角色：ConcreteState（具体状态子类）每个子类实现与Context的一个状态相关的行为
5. 优缺点
5.1 优点
  • 1.将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
  • 2.允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
5.2 缺点
  • 1.状态模式的使用必然会增加系统类和对象的个数。
  • 2.状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
  • 3.状态模式对"开闭原则"的支持并不太好。
6. java示例
6.1 非状态模式
6.1.1 问题分析
  • 1.使用了大量的switch case这样的判断（if else也是一样），使程序的可阅读性变差
  • 2.扩展性差，如果新加了一种状态，则需要修改判断逻辑
6.1.2 接口类
package com.learning.state.before;

/**
 * 电梯接口
 */
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();
}
6.1.2 实现类
package com.learning.state.before;

/**
 * @Description 电梯类
 **/
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:
                //什么都不做
                break;
            //如果当前电梯状态是关闭状态，打开电梯
            case CLOSING_STATE:
                System.out.println("电梯打开了");
                // 设置当前电梯状态为开启状态
                setState(OPENING_STATE);
                break;
            //如果当前电梯状态是运行状态
            case RUNNING_STATE:
                //什么都不做
                break;
            //如果当前电梯状态是开启状态，打开电梯
            case STOPPING_STATE:
                System.out.println("电梯打开了");
                setState(OPENING_STATE);
                break;

        }
    }

    @Override
    public void close() {
        switch(this.state) {
            case OPENING_STATE:
                //只有开门状态可以关闭电梯门
                System.out.println("电梯关门了");
                //关门之后电梯就是关闭状态了
                this.setState(CLOSING_STATE);
                break;
            case CLOSING_STATE:
                //已经是关门状态，不能关门
                //什么都不做
                break;
            case RUNNING_STATE:
                //运行时电梯门是关着的，不能关门
                //什么都不做
                break;
            case STOPPING_STATE:
                //停止时电梯也是关着的，不能关门
                //什么都不做
                break;
        }
    }

    @Override
    public void run() {
        switch(this.state) {
            case OPENING_STATE:
                //电梯不能开着门运行
                break;
            case CLOSING_STATE:
                //门关了，可以运行了
                System.out.println("电梯运行了");
                //设置为运行状态
                this.setState(RUNNING_STATE);
                break;
            case RUNNING_STATE:
                //已经是运行状态了
                break;
            case STOPPING_STATE:
                System.out.println("电梯运行了");
                //设置为运行状态
                this.setState(RUNNING_STATE);
                break;
        }
    }

    @Override
    public void stop() {
        switch(this.state) {
            case OPENING_STATE:
                // 开门的电梯已经是是停止的了(正常情况下)
                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:
                break;
        }
    }
}
6.1.3 客户端
package com.learning.state.before;

/**
 * 客户端
 */
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();
    }
}
6.1.4 结果截图

在这里插入图片描述

6.2 状态模式
6.2.1 抽象状态类
package com.learning.state.after;

/**
 * 抽象状态类
 */
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();
}
6.2.2 状态类
  • 1.开启状态类
package com.learning.state.after;

/**
 * 开启状态类
 */
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() {
        // 什么都不做
    }
}
  • 2.运行状态类
package com.learning.state.after;

/**
* 运行状态类
*/
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();
   }
}
  • 3.停止状态类
package com.learning.state.after;

/**
 * 停止状态类
 */
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("电梯停止了");
    }
}
  • 4.关闭状态类
package com.learning.state.after;

/**
 * 关闭状态类
 */
public class ClosingState extends LiftState {

    /**
     * 电梯关闭状态可以再打开
     */
    @Override
    public void open() {
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.open();
    }

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

    /**
     * 电梯关门之后启动
     */
    @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();
    }
}
6.2.3 上下文类
package com.learning.state.after;

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

}
6.2.4 上下文类
package com.learning.state.after;

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

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

    }
}
王佑辉
关注
专栏目录
软考高级系统架构设计师系列之：UML建模、设计模式和软件架构设计章节选择题详解
zhengzaifeidelushang的博客
11-01 601
软考高级系统架构设计师系列之：UML建模、设计模式和软件架构设计章节选择题详解
案例分析篇03：一篇文章搞定软考设计模式考点（2024年软考高级系统架构设计师冲刺知识点总结系列文章）
随风浪仔的专栏
03-11 738
案例分析篇03：一篇文章搞定软考设计模式考点（2024年软考高级系统架构设计师冲刺知识点总结系列文章），一句话总结23个设计模式意图、解决方法；创建型模式 5种，结构型模式7种，行为型模式11种。
详解状态模式
最新发布
如无必要，勿增实体。
10-02 822
状态模式和策略模式都涉及行为的变化，但状态模式是根据内部状态的变化来改变行为，而策略模式是根据外部条件选择不同的算法或策略。状态模式封装了对象的状态，并且状态之间的转换是自动的，而策略模式封装的是算法或策略，需要客户端显式选择。观察者模式则主要用于实现对象之间的依赖关系，适用于事件驱动的系统[[无直接证据]]。状态模式的核心思想是将状态和行为封装在独立的类中，并允许对象在运行时根据当前状态改变其行为。不同编程语言在实现这一模式时，主要差异在于语法和设计细节。
设计模式（十五）状态模式
Android进阶三部曲 - 刘望舒
04-17 2806
建议在阅读本文前先阅读设计模式（十一）策略模式这篇文章，虽说状态模式和策略模式的结构几乎是相同的，但是它们所解决的问题是不同的，读完这两篇文章你就会有了答案。
《JAVA与模式》之状态模式
weixin_30838921的博客
06-08 273
在阎宏博士的《JAVA与模式》一书中开头是这样描述状态（State）模式的： 　　状态模式，又称状态对象模式（Pattern of Objects for States），状态模式是对象的行为模式。 　　状态模式允许一个对象在其内部状态改变的时候改变其行为。这个对象看上去就像是改变了它的类一样。 状态模式的结构 　　用一句话来表述，状态模式把所研究的对象的行为包装在不同的状态对象里，每一个...
状态模式
GreedySnaker的博客
02-06 210
一 简介 状态模式(State Pattern)也称为状态机模式(State Machine Pattern)，是允许对象在内部状态发生改变的同时改变对象的行为，使得看起来像是修改了类一样。 状态模式中的类的行为是由状态决定的，不同的状态有不同的行为。状态模式的意图是让一个对象在其内部改变时行为也随之一起改变。 状态模式的核心就是给每一种状态绑定一种行为。 二 UML图 State类：抽象状态类，定义一个接口以封装与Context的一个特定状态相关的行为。 ConcreteState类：具体状态，每一个
软考中级-软件设计师 23种设计模式
热门推荐
Y的博客
10-09 1万+
软考中级-软件设计师 23种设计模式
软考之设计模式
Ms_future的博客
05-30 475
装饰模式: 对象结构型模式，可动态地给一个对象增加一些额外的职责 就增加对象功能来说，装饰模式比生成子类实现更为灵活。通过装饰 模式，可以在不影响其他对象的情况下，以动态、透明的方式给单个 对象添加职责;当需要动态地给一个对象增加功能时，这些功能可以在 动态地被撤销时使用装饰模式;当不能采用生成子类的方法进行扩充时, 也可使用装饰模式。 外观模式: 对象的结构模式，要求外部与一...
软考-常见的23种设计模式整理
ppliu的博客
09-16 1082
23种设计模式
软考设计模式——状态模式（C++篇）
amazingdyd的博客
11-08 468
状态模式顾名思义就是通过改变状态来控制对象的行为。 举个简单的例子，把一个人（这个人会实例化成一个对象）分为青年，中年，老年三种状态，在每个年龄阶段可以干不同的事情。 #include #include using namespace std; class Person; //因为要用到person，所以先声明一下 class State{ //设定抽象类：状态类，这个类用来获取当前人的状
编程语言学习资源大放送：设计模式与软考资料
在“AS3 设计模式”这一主题中，我们讨论的是ActionScript 3.0中的设计模式。设计模式是软件工程中经过实践证明有效的解决方案模板，它们为常见的问题或场景提供了解决策略。AS3作为Adobe Flash平台的主要编程语言，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

王佑辉

老板，赏点吧

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

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

打赏作者

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

抵扣说明：

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

余额充值