状态设计模式

已于 2023-08-12 10:58:50 修改
阅读量195 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java 状态模式
于 2022-07-02 07:26:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43459116/article/details/125568493
版权

在这里插入图片描述

状态模式

1 概述

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

类图如下：

代码如下：

public interface ILift {
    //电梯的4个状态
    //开门状态
    public final static int OPENING_STATE = 1;
    //关门状态
    public final static int CLOSING_STATE = 2;
    //运行状态
    public final static int RUNNING_STATE = 3;
    //停止状态
    public final static int STOPPING_STATE = 4;
    //设置电梯的状态
    public void setState(int state);
    //电梯的动作
    public void open();
    public void close();
    public void run();
    public void stop();
}

public class Lift implements ILift {
    private int state;

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

    //执行关门动作
    @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 open() {
        switch (this.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 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;
        }
    }

    //执行停止动作
    @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;
        }
    }
}

public class Client {
    public static void main(String[] args) {
        Lift lift = new Lift();
        lift.setState(ILift.STOPPING_STATE);//电梯是停止的
        lift.open();//开门
        lift.close();//关门
        lift.run();//运行
        lift.stop();//停止
    }
}

问题分析：

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

定义：

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

2 结构

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

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

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 OpenningState extends LiftState {
    //开启当然可以关闭了，我就想测试一下电梯门开关功能
    @Override
    public void open() {
        System.out.println("电梯门开启...");
    }
    @Override
    public void close() {
        //状态修改
        super.context.setLiftState(Context.closeingState);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().close();
    }
    //电梯门不能开着就跑，这里什么也不做
    @Override
    public void run() {
        //do nothing
    }

    //开门状态已经是停止的了
    @Override
    public void stop() {
        //do nothing
    }
}

//运行状态
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.stoppingState);
        super.context.stop();
    }
}

//停止状态
public class StoppingState extends LiftState {
    //停止状态，开门，那是要的！
    @Override
    public void open() {
        //状态修改
        super.context.setLiftState(Context.openningState);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().open();
    }
    @Override
    public void close() {//虽然可以关门，但这个动作不归我执行
        //状态修改
        super.context.setLiftState(Context.closeingState);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().close();
    }
    //停止状态再跑起来，正常的很
    @Override
    public void run() {
        //状态修改
        super.context.setLiftState(Context.runningState);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().run();
    }
    //停止状态是怎么发生的呢？当然是停止方法执行了
    @Override
    public void stop() {
        System.out.println("电梯停止了...");
    }
}

//关闭状态
public class ClosingState extends LiftState {
    @Override
    //电梯门关闭，这是关闭状态要实现的动作
    public void close() {
        System.out.println("电梯门关闭...");
    }
    //电梯门关了再打开，逗你玩呢，那这个允许呀
    @Override
    public void open() {
        super.context.setLiftState(Context.openningState);
        super.context.open();
    }
    //电梯门关了就跑，这是再正常不过了
    @Override
    public void run() {
        super.context.setLiftState(Context.runningState);
        super.context.run();
    }
    //电梯门关着，我就不按楼层
    @Override
    public void stop() {
        super.context.setLiftState(Context.stoppingState);
        super.context.stop();
    }
}

//环境角色
public class Context {
    //定义出所有的电梯状态
    public final static OpenningState openningState = new OpenningState();//开门状态，这时候电梯只能关闭
    public final static ClosingState closeingState = new ClosingState();//关闭状态，这时候电梯可以运行、停止和开门
    public final static RunningState runningState = new RunningState();//运行状态，这时候电梯只能停止
    public final static StoppingState stoppingState = new StoppingState();//停止状态，这时候电梯可以开门、运行


    //定义一个当前电梯状态
    private LiftState liftState;

    public LiftState getLiftState() {
        return this.liftState;
    }

    public void setLiftState(LiftState liftState) {
        //当前环境改变
        this.liftState = liftState;
        //把当前的环境通知到各个实现类中
        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.close();
        context.run();
        context.stop();
    }
}

4 优缺点

1，优点：

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

2，缺点：

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

5 使用场景

  • 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
  • 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。
孤叶飘落
关注
专栏目录
详解状态模式
努力学习游泳的鱼的博客
10-02 813
状态模式和策略模式都涉及行为的变化，但状态模式是根据内部状态的变化来改变行为，而策略模式是根据外部条件选择不同的算法或策略。状态模式封装了对象的状态，并且状态之间的转换是自动的，而策略模式封装的是算法或策略，需要客户端显式选择。观察者模式则主要用于实现对象之间的依赖关系，适用于事件驱动的系统[[无直接证据]]。状态模式的核心思想是将状态和行为封装在独立的类中，并允许对象在运行时根据当前状态改变其行为。不同编程语言在实现这一模式时，主要差异在于语法和设计细节。
设计模式：状态设计模式
weixin_44251099的博客
05-25 426
状态设计模式的概念和作用状态设计模式是一种行为型设计模式，它可以有效地管理对象的状态，使对象在不同的状态下具有不同的行为和属性。状态设计模式将对象状态的转换和判断封装到不同的状态类中，从而提高代码的可扩展性和可维护性。状态设计模式是一种常用的行为型设计模式，可以有效地管理对象的状态，使对象在不同状态下具有不同的行为和属性。状态设计模式由状态接口、具体状态类和上下文类等组成部分，通过状态转换和状态判断等逻辑实现状态的变化和行为的变化。
【设计模式】行为模式——状态模式
这里是Mae。
05-04 560
行为模式——状态模式
unity3D FSM有限状态机（状态设计模式）
热门推荐
liaosheng：）
07-12 2万+
前言 为了解决游戏过于麻烦的状态转换（人物动画过多），使用有限状态机 缺点：代码量大 编写 使用多态和Switch new（状态设计模式） 类的介绍 PlyayCtrl:挂载在角色身上的脚本，用来控制状态机，（控制状态机中状态的切换）。 Machine:状态机器类，储存所有状态，对状态进行切换，和状态的保持工作。 Base: 状态的基类，给子类提供接口（方法） Tem...
设计模式 -- 状态模式（State Pattern）
魔法师之家
03-22 1518
允许一个对象在内部状态改变时改变它的行为。 应用场景 一个对象的行为取决于它的状态，并且它在运行时根据状态改变它的行为。 代码中包含大量与对象状态相关的判断语句。 优点： 将不同的状态隔离 把各种状态的转换逻辑，分布到State的子类中，减少相互间依赖 增加新的状态非常简单 状态模式与责任链模式的区别 状态模式和责任链模式都能消除 if-else 分支过多的问题。但在某些情况下，状态模式中的状态可以理解为责任，那么在这种情况下，两种模式都可以使用。
55-Java设计模式之策略模式与状态模式1
08-08
Java 设计模式之策略模式与状态模式 策略模式是 Java 中的一种设计模式，它主要用于解决系统与第三方接口进行数据交互的问题。当系统需要与多种格式的数据进行交互时，使用策略模式可以很好地解决这个问题。例如，...
java常用设计模式-状态模式
最新发布
08-28
Java 架构设计模式 - 状态模式和模板模式 在软件设计中，了解设计模式非常重要，它可以帮助开发者编写更好的代码，使得系统更加灵活、可维护和可扩展。今天，我们将讨论两种常用的Java设计模式：状态模式和模板模式...
Java中的状态设计模式
最佳 Java 编程
06-13 222
在本教程中，我们将探讨另一种流行的行为设计模式-状态设计模式。 当我们使用可以存在于多个状态的对象时，状态设计模式的知识变得非常有用。 当对象的行为取决于其当前状态时，我们应该主要使用它。 这种模式有助于我们避免在该类的方法中对对象的状态进行长时间的条件检查。 有了它，让我们开始吧！ 状态设计模式： 我们可以用以下UML图表示状态设计模式： 哪里， 状态–表示一个抽象...
设计模式：状态模式（State）
朱小厮的博客
04-25 7624
允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。 状态模式的角色 1. 环境角色Context）：也称上下文，定义客户端所感兴趣的接口，并且保留一个具体状态类的实例。这个具体状态类的实例给出此环境对象的现有状态。 2. 抽象状态角色（State）：定义一个接口，用以封装环境对象的一个特定的状态所对应的行为。 3. 具体状态角色（ConcreteState）：每一个具体
状态设计模式（行为型设计模式）
Stitch12的博客
12-03 574
一、状态设计模式简介 状态设计模式(State Pattern) 对象的⾏为依赖于它的状态（属性），并且可以根据它的状态改变⽽改变它的相关⾏为 ,属于⾏为型模式 允许⼀个对象在其内部状态改变时改变它的⾏为 状态模式是策略模式的孪⽣兄弟，它们的UML图是⼀样的，但实际上解决的是不同情况的两种场景问题 ⼯作中⽤的不多，基本策略模式⽐较多 应用场景 ⼀个对象的⾏为取决于它的状态, 并且它必须在运⾏时刻根据状态改变它的⾏为 代码中包含⼤量与对象状态有关的条件语句 ，⽐如⼀个 操作中含有庞⼤的多分⽀的条
实用设计模式之状态模式
文斌咨询
03-17 4830
状态模式的针对性很强，当有状态变化的时候很多工程师会倾向于选择状态模式，但在使用时仍然存在着很多问题，比如状态的拆分不清晰、状态的变迁不准确、类的职责划分不单一等，一旦与具体的业务逻辑和已有的代码上下文放在一起，就出现了混乱。因此，本文以一个实际的例子来总结一下在现实当中如何使用状态模式。 1.什么是状态模式        状态模式(State Pattern)是设计模式的一种，属于行为模式。其定
设计模式之状态设计模式
HelloWorld!
06-27 263
一、状态确立 万事万物都有状态，这个模式强调的就是对状态的把控，可以很轻松的在各个状态之间来回切换。 那我们先明确一下状态模式的定义： 允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。 简单理解就是在内部操控状态(调起了别的方法)但是外部对此感知好像是修改了它的类一般。 再拿类图来理解一下: 图中的三个角色： Context:环境角色由它负责状态的切换； ...
JavaScript设计模式：状态模式实例详解
"深入理解JavaScript系列（43）：设计模式之状态模式详解"这一篇文章详细探讨了JavaScript中的状态模式，这是一种行为设计模式，主要用于解决对象在不同状态下表现出不同行为的问题。状态模式的核心理念是将对象的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值