23种设计模式--状态模式

最新推荐文章于 2024-05-20 00:15:00 发布
最新推荐文章于 2024-05-20 00:15:00 发布
阅读量1.4k 收藏 7
点赞数 1
分类专栏： java 程序员内功--设计模式 文章标签： 状态模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Martin_chen2/article/details/121212413
版权

状态模式

一、基本概念

在软件开发过程中，应用程序中的部分对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。
当有状态的对象与外部事件产生互动时，其内部状态就会发生改变，从而使其行为也发生改变。

对这种有状态的对象编程，传统的解决方案是：将这些所有可能发生的情况全都考虑到，然后使用 if-else 或 switch-case 语句来做状态判断，再进行不同情况的处理。
但是显然这种做法对复杂的状态判断存在天然弊端，条件判断语句会过于臃肿，可读性差，且不具备扩展性，维护难度也大。且增加新的状态时要添加新的 if-else 语句，这违背了“开闭原则”，不利于程序的扩展。

二、主要思想

以上问题如果采用“状态模式”就能很好地得到解决。状态模式的解决思想是：当控制一个对象状态转换的条件表达式过于复杂时，把相关“判断逻辑”提取出来，用各个不同的类进行表示，系统处于哪种情况，直接使用相应的状态类对象进行处理，这样能把原来复杂的逻辑判断简单化，消除了 if-else、switch-case 等冗余语句，代码更有层次性，并且具备良好的扩展力。

优点：

  1. 结构清晰，状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。
  2. 将状态转换显示化，减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。
  3. 状态类职责明确，有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。

缺点：

  1. 状态模式的使用必然会增加系统的类与对象的个数。
  2. 状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。
  3. 状态模式对开闭原则的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源码，否则无法切换到新增状态，而且修改某个状态类的行为也需要修改对应类的源码。

一句话总结
把判断对象状态的复杂“判断逻辑”提取到子类中，允许子类在其内部状态发生改变时改变其行为。

三、使用场景

在这里插入图片描述

订单的状态有很多种，有待支付、待发货等等，而且每种状态下的订单处理逻辑也比较多，在这个过程中如果使用硬编码，我们就需要一系列的 if-else 语句来检查订单的当前状态、可执行操作以及这两个组合得到的下一个应该被流转的状态值。如果订单的状态流转很复杂，代码逻辑就会很复杂，可拓展性弱，可读性低，后期维护困难。

对于这种情况，我们可以使用状态机模式来处理。

四、应用实例

在这里插入图片描述

上面是状态的模式的雷图，主要包含三种角色：

  1. 订单环境类（OrderContext）角色：
    也称为上下文，它定义了客户端需要的接口，内部维护一个当前状态，并负责具体状态的切换。
  2. 抽象状态（OrderState）角色：
    定义一个接口，用以封装环境对象中的特定状态所对应的行为，可以有一个或多个行为。
  3. 具体状态（WaitPay、WaitRecv、WaitSend、WaitValuate、Finished）角色：
    实现抽象状态所对应的行为，并且在需要的情况下进行状态切换。

OrderContext代码实现如下：

/**
 * @Author dingws
 * @PackageName JavaStudy
 * @Package org.goodStudy.designPattern.stateMode
 * @Date 2021/11/8 4:10 下午
 * @Version 1.0
 */
public class OrderContext {
    State state = State.WAIT_PAY;

    OrderState orderState = new WaitPay();

    public void OrderContext(){
        orderState = new WaitPay();
    }

    public void Handle(){
        orderState.Handle(this);
    }

    public State getState() {
        return state;
    }

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

    public OrderState getOrderState(){
        return this.orderState;
    }

    public void setOrderState(OrderState orderState) {
        this.orderState = orderState;
    }

    /**
     * main函数
     * @param args
     */
    public static void main(String[] args) {
        OrderContext orderContext = new OrderContext();
        orderContext.Handle();
        orderContext.Handle();
        orderContext.Handle();
        orderContext.Handle();
        orderContext.Handle();
    }
}

OrderState的代码实现如下：

/**
 * @Author dingws
 * @PackageName JavaStudy
 * @Package org.goodStudy.designPattern.stateMode
 * @Date 2021/11/2 2:15 下午
 * @Version 1.0
 */
public abstract class OrderState {
    public abstract void Handle(OrderContext orderContext);
}

WaitPay、WaitRecv、WaitSend、WaitValuate、Finished 的代码实现如下：

/**
 * @Author dingws
 * @PackageName JavaStudy
 * @Package org.goodStudy.designPattern.stateMode
 * @Date 2021/11/2 2:15 下午
 * @Version 1.0
 */
class WaitPay extends OrderState {

    @Override
    public void Handle(OrderContext orderContext) {
        if (orderContext.getState() == State.WAIT_PAY){
            System.out.println("用户已付款，等待发货");
            orderContext.setState(State.WAIT_SEND);
            orderContext.setOrderState(new WaitSend());
        } else {
            System.out.println("等待用户支付，当前订单状态为：" + orderContext.getState().getName());
        }
    }
}

class WaitSend extends OrderState {

    @Override
    public void Handle(OrderContext orderContext){
        if (orderContext.getState() == State.WAIT_SEND){
            System.out.println("卖家已发货，等待订单签收");
            orderContext.setState(State.WAIT_RECV);
            orderContext.setOrderState(new WaitRecv());
        } else {
            System.out.println("等待卖家发货，当前订单状态为：" + orderContext.getState().getName());
        }
    }
}

class WaitRecv extends OrderState {

    @Override
    public void Handle(OrderContext orderContext){
        if (orderContext.getState() == State.WAIT_RECV){
            System.out.println("订单已签收，等待用户评价");
            orderContext.setState(State.WAIT_VALUATE);
            orderContext.setOrderState(new WaitValuate());
        } else {
            System.out.println("等待用户签收订单，当前订单状态为：" + orderContext.getState().getName());
        }
    }
}

class WaitValuate extends OrderState {

    @Override
    public void Handle(OrderContext orderContext){
        if (orderContext.getState() == State.WAIT_VALUATE){
            System.out.println("用户已评价，订单关闭");
            orderContext.setState(State.FINISHED);
            orderContext.setOrderState(new Finished());
        } else {
            System.out.println("等待卖家发货，当前订单状态为：" + orderContext.getState().getName());
        }
    }
}

class Finished extends OrderState{

    @Override
    public void Handle(OrderContext orderContext){
        if (orderContext.getState() == State.FINISHED){
            System.out.println("订单已完成");
        } else {
            System.out.println("等待订单完成，当前订单状态为：" + orderContext.getState().getName());
        }
    }
}

State枚举类的实现代码如下：

/**
 * @Author dingws
 * @PackageName JavaStudy
 * @Package org.goodStudy.designPattern.stateMode
 * @Date 2021/11/2 2:07 下午
 * @Version 1.0
 */
public enum State {
    WAIT_PAY(1, "待付款"),
    WAIT_SEND(2, "待发货"),
    WAIT_RECV(3, "待签收"),
    WAIT_VALUATE(4, "待评价"),
    FINISHED(5, "订单已完成");

    private final int id;
    private final String name;

    State(int id, String name){
        this.id = id;
        this.name = name;
    }

    State(State state){
        this.id = state.id;
        this.name = state.name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

运行结果如下：

在这里插入图片描述

五、拓展

以上就是状态机的详细讲解了，在运行后，我发现一个问题，各个具体状态之间（WaitPay、WaitRecv、WaitSend、WaitValuate、Finished），需要依赖自己要状态跳转的类，这样耦合度就增加了，有没有更好的办法呢？

于是，我在上面的版本上，又优化了一版。

在这里插入图片描述

相较于上个版本，此版本仅增加了一个Active枚举类，在各个状态类中，仅需要关注触发的条件和跳转到的恶状态即可，不需要知道别的具体处理类，更大限度的减少了耦合性。

Active状态实现：

/**
 * @Author dingws
 * @PackageName JavaStudy
 * @Package org.goodStudy.designPattern.stateMode
 * @Date 2021/11/2 2:24 下午
 * @Version 1.0
 */
public enum Active {
    ACTIVE_PAY(1, "付款"),
    ACTIVE_SEND(2, "发货"),
    ACTIVE_RECV(3, "签收"),
    ACTIVE_VALUATE(4, "评价"),
    ACTIVE_CACLE(5, "取消");

    private final int id;
    private final String name;


    Active(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

OrderContext实现

/**
 * @Author dingws
 * @PackageName JavaStudy
 * @Package org.goodStudy.designPattern.stateMode
 * @Date 2021/11/8 4:10 下午
 * @Version 1.0
 */
public class OrderContext {
    OrderState orderState;

    public void OrderContext(){
        orderState = new WaitPay();
    }

    public void Handle(Active active){
        orderState.Handle(active);
    }

    public void setOrderState(OrderState orderState) {
        this.orderState = orderState;
    }

    public static void main(String[] args) {
        OrderContext orderContext = new OrderContext();
        orderContext.setOrderState(new WaitPay());
        orderContext.Handle(Active.ACTIVE_PAY);

        System.out.println("-------");
        orderContext.Handle(Active.ACTIVE_VALUATE);
        System.out.println("-------");

        orderContext.setOrderState(new WaitSend());
        orderContext.Handle(Active.ACTIVE_SEND);
        orderContext.setOrderState(new WaitRecv());
        orderContext.Handle(Active.ACTIVE_RECV);
        orderContext.setOrderState(new WaitValuate());
        orderContext.Handle(Active.ACTIVE_VALUATE);
        orderContext.setOrderState(new Finished());
        orderContext.Handle(Active.ACTIVE_VALUATE);
    }
}

OrderState实现：

/**
 * @Author dingws
 * @PackageName JavaStudy
 * @Package org.goodStudy.designPattern.stateMode
 * @Date 2021/11/2 2:15 下午
 * @Version 1.0
 */
public class OrderState {
    protected State state = State.FINISHED;

    void OrderState(){
        state = State.FINISHED;
    }

    public void Handle(Active active){

    }
}

class WaitPay extends OrderState {

    @Override
    public void Handle(Active active){
        if (active == Active.ACTIVE_PAY){
            System.out.println("用户已付款，等待发货");
            this.state = State.WAIT_SEND;
        } else if (active == Active.ACTIVE_CACLE) {
            this.state = State.FINISHED;
        } else {
            System.out.println("等待用户支付，当前订单状态为：" + state.getName());
        }
    }
}

class WaitSend extends OrderState {

    @Override
    public void Handle(Active active){
        if (active == Active.ACTIVE_SEND){
            System.out.println("卖家已发货，等待订单签收");
            this.state = State.WAIT_RECV;
        } else {
            System.out.println("等待卖家发货，当前订单状态为：" + state.getName());
        }
    }
}

class WaitRecv extends OrderState {

    @Override
    public void Handle(Active active){
        if (active == Active.ACTIVE_RECV){
            System.out.println("订单已签收，等待用户评价");
            this.state = State.WAIT_VALUATE;
        } else if (active == Active.ACTIVE_CACLE) {
            if (state == State.WAIT_SEND){
                System.out.println("商品未发货，取消订单成功");
                this.state = State.FINISHED;
            } else {
                System.out.println("商品未发货，取消订单失败");
            }
        }  else {
            System.out.println("等待用户签收订单，当前订单状态为：" + state.getName());
        }
    }
}

class WaitValuate extends OrderState {

    @Override
    public void Handle(Active active){
        if (active == Active.ACTIVE_VALUATE){
            System.out.println("用户已评价，订单关闭");
            this.state = State.FINISHED;
        } else {
            System.out.println("等待卖家发货，当前订单状态为：" + state.getName());
        }
    }
}

class Finished extends OrderState{

    @Override
    public void Handle(Active active){
        if (state == State.FINISHED){
            System.out.println("订单已完成");
        } else {
            System.out.println("等待订单完成，当前订单状态为：" + state.getName());
        }
    }
}

参考链接：
https://blog.csdn.net/qq_33000453/article/details/106749593
http://c.biancheng.net/view/1388.html
http://c.biancheng.net/view/8492.html

终成一个大象
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
状态模式（State Pattern）
笔记别偷看
12-21 5990
APP 抽奖活动问题 请编写程序完成APP 抽奖活动具体要求如下: 假如每参加一次这个活动要扣除用户50 积分，中奖概率是10% 奖品数量固定，抽完就不能抽奖 活动有四个状态: 可以抽奖、不能抽奖、发放奖品和奖品领完 活动的四个状态转换关系图(下图) 状态模式基本介绍 基本介绍 状态模式（State Pattern）：它主要用来解决对象在多种状态转换时，需要对外输出不同的行为的问题。状态和行为是一一对应的，状态之间可以相互转换 当一个对象的内在状态改变时，允许改变其行为，这个对
设计模式-状态机模式
zbbzb的博客
02-18 2189
设计模式-状态机
设计模式：状态模式（State）
最新发布
ProgramNovice的博客
05-20 1128
设计模式：状态模式（State）
设计模式 状态机
baiiu
02-19 1214
本文梳理状态机概念，在实操中状态机和类似，只是被封装起来，可以很方便的实现状态初始化和状态转换。
设计模式之状态模式
weixin_39765162的博客
04-07 409
状态模式，又称状态机模式，属于行为型设计模式的一种，定义：允许一个对象在内部状态发生改变时改变其行为，就好像是改变了自身的类一样。如果状态简单，这种if else语句看上去是没有问题的，但是如果状态变得复杂起来，多种状态之间互相作用，关联，这种代码就会变得非常复杂，比如使用大量的flag去维护状态和状态之间的转换，使得这部分代码变得难以维护，最重要的是这部分代码将在客户端进行维护，客户端不得不关心各个状态之间的转换和具体的行为。
状态模式（State模式）
qq_35784669的博客
11-09 9978
在软件开发过程中，应用程序中的部分对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。当有状态的对象与外部事件产生互动时，其内部状态就会发生改变，从而使其行为也发生改变。如人都有高兴和伤心的时候，不同的情绪有不同的行为，当然外界也会影响其情绪变化。 对这种有状态的对象编程，传统的解决方案是：将这些所有可能发生的情况全都考虑到，然后使用 if-else 或 switch-case 语句来做状态判断，再进行不同情况的处理。但是显然这种做法对
23种设计模式-C++实现.zip
05-16
这个名为"23种设计模式-C++实现.zip"的压缩包文件包含了C++语言实现的全部23个经典设计模式。下面我们将详细探讨这些设计模式及其在C++中的应用。 1. **创建型设计模式**： - **单例模式（Singleton）**：确保一个...
java常用设计模式-状态模式
08-28
今天，我们将讨论两种常用的Java设计模式：状态模式和模板模式。 状态模式（State Pattern） --------------------- 状态模式是一种行为型设计模式，它允许对象在内部状态改变时改变它的行为。状态模式将状态封装...
设计模式-状态模式.pdf
05-16
设计模式 -状态模式.pdf
JAVA设计模式-原则和23种设计模式归纳总结
11-24
JAVA设计模式-原则和23种设计模式归纳总结 本资源主要介绍了JAVA设计模式的原则和23种设计模式的总结。设计模式是软件设计中的一种解决方案，能够使软件系统更加灵活、可维护和可扩展。本资源首先介绍了设计模式的...
c++设计模式-行为型模式-状态模式
06-20
c++设计模式-行为型模式-状态模式；qt工程；c++简单源码； 状态（State）模式的定义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。
设计模式之状态模式(State)
07-07
状态模式（State） 用意：允许一个对象当状态改变时，改变其行为。
设计模式——状态模式
海纳百川
03-06 331
设计模式——状态模式 一、基本概念 1. 定义 状态（State）模式：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。 状态模式是一种行为设计模式， 让你能在一个对象的内部状态变化时改变其行为， 使其看上去就像改变了自身所属的类一样。 2. 优缺点 优点： 结构清晰，状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”； 将状态转换显示化，减少对象间的相互依赖。将不同的状态引入独立的对象中会使得
如何设计一个状态机！
架构文摘
05-31 2155
1、什么是状态机1.1 什么是状态先来解释什么是“状态”（ State ）。现实事物是有不同状态的，例如一个自动门，就有 open 和 closed 两种状态。我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如自动门的状态就是两个 open 和 closed 。状态机，也就是 State Machine ，不是指一台实际机器，而是指一个数学模型。说白了，一般就是指一张状...
设计模式之美64-状态模式：游戏、工作流引擎中常用的状态机是如何实现的？
fegus的博客
05-06 670
有限状态机，英文翻译是Finite State Machine，缩写为FSM，简称为状态机。状态机有3个组成部分：状态（State）、事件（Event）、动作（Action）。其中，事件也称为转移条件（Transition Condition）。事件触发状态的转移及动作的执行。不过，动作不是必须的，也可能只转移状态，不执行任何动作。对于刚刚给出的状态机的定义，我结合一个具体的例子，来进一步解释一下。“超级马里奥”游戏不知道你玩过没有？
【设计模式】状态模式 ( 简介 | 适用场景 | 优缺点 | 代码示例 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
08-14 6491
一、状态模式简介、 二、状态模式适用场景、 三、状态模式优缺点、 四、状态模式相关设计模式、 五、状态模式代码示例、 1、状态类父类、 2、播放状态类、 3、暂停状态类、 4、快进状态类、 5、停止状态类、 6、上下文控制类、 7、测试、
23种设计模式之状态模式和策略模式的区别
致力于不留技术债务cuizb.top
08-23 4394
在行为类设计模式中，状态模式和策略模式是亲兄弟，两者非常相似，我们先看看两者的通用类图，把两者放在一起比较一下状态模式与策略模式很相似，确切的说状态模式包含策略模式。策略模式封装的是行为，而状态模式封装的是变化。尽管这么说，但事实上策略模式与状态模式在很多情况下都是可以互相转化的，具体应该使用何种模式，就要从上面的两个方面尽心分析，能够看得出明显状态变化的，当热要用状态模式；...
【设计模式】状态模式（状态机）
keeper42的博客
02-12 1796
先介绍下状态机，状态机一般由三部分组成：状态（State）、事件（Event）、动作（Action）。其中，事件也称为转移条件（Transition Condition）。事件 触发 状态的转移及动作的执行。不过，动作不是必须的，可能只转移状态，不执行任何动作。 状态模式通过将事件触发的状态转移和动作执行，拆分到不同的状态类中，来避免分支判断逻辑。下面展示“超级马里奥”小游戏的游戏状态之间的状态转换， public interface IMario { State getName(); vo
23种设计模式——状态模式
qq_51165184的博客
05-11 2992
状态模式本质：根据状态来分离和选择行为。状态驱动，上下文负责
图解Java设计模式-23种设计模式
08-28
下面是常见的23种设计模式： 1. 创建型模式（Creational Patterns）： - 工厂方法模式（Factory Method Pattern） - 抽象工厂模式（Abstract Factory Pattern） - 单例模式（Singleton Pattern） - 原型模式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值