设计模式之状态模式

最新推荐文章于 2024-08-06 16:21:17 发布
最新推荐文章于 2024-08-06 16:21:17 发布
阅读量306 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 Java 交流 状态模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18870127/article/details/82347186
版权

状态模式，我们给他一个通俗的定义：在我们改变某一个对象的内部状态的时候，我们也要同时改变它的行为，表面上是改变了动作和行为，实际上则是改变了类的内部的状态。通过这个定义我们可以隐约的猜想到，我们在改变的状态的时候，其实是改变的一个类，也就是说一个类封装了一个状态，这个思想和策略模式比较像，将变化的封装起来，在策略模式中封装的是一个算法，以及算法的流程，其算法的大致过程一致，只是具体到某一个算法时会进行区分，可以看到这个组合的思想也能在状态模式中体现出来。类似于下面的表达：

  State:实际上定义了一个所有具体状态的共同接口，任何状态都是用这个接口，这样状态之间就可以互相替换。ConcreteA和ConcreteB两个处理来自Context的请求，每一个ContextState都提供了他自己对请求的实现

考虑下面一个例子：假如有一个糖果机，一个糖果的价格是25美分，糖果机默认状态是没有25美分的状态，当向糖果机中投入25美分后，我们就可以从糖果机的曲柄转动得到一个糖果，此时就出售了糖果，而当糖果机中没有糖果时，就会发出糖果售罄的状态，同时退换投入的25美分。我们发现在这个逻辑过程中，除了动作外，状态也是会发生改变的，所以，综合分析来看，我们有5个状态：投入25美分，退回25美分，转动曲柄，发放糖果，糖果售罄。分析后我们首先用类图设计，然后用代码来表示：

类图设计为：

实现为(完整代码地址为：GOGOGO)：

/**
 * @author Tianlong Zhang
 * @time 2018/9/3 10:17
 * @project DesignPattern
 * @Version 1.0.0
 */
public class GumballMachine {

    //定义状态字段

    /*糖果售罄*/
    final static int SOLD_OUT = 0;

    /*没有投入25美分，默认初始状态*/
    final static int NO_QUARTER = 1;

    /*投入25美分*/
    final static int HAS_QUARTER = 2;

    /*糖果发放*/
    final static int SOLD = 3;

    int state = SOLD_OUT;

    /*糖果数量*/
    int count = 0;

    public GumballMachine(int count){
        this.count = count;
        if(count > 0){
            state = NO_QUARTER;
        }
    }
    /**
     *定义了四个动作，分别对应着不同状态的动作，每当动作发生时检查状态，然后再进行处理
     */


    /**
     *插入25美分
     */
    public void insertQuarter(){
        if(state == HAS_QUARTER){
            System.out.println("You can't insert another quarter");
        }else if(state == NO_QUARTER){
            state = HAS_QUARTER;
            System.out.println("You insert a quarter");
        }else if(state == SOLD_OUT){
            System.out.println("You can't insert a quarter, the machine is sold out");
        }else if(state == SOLD){
            System.out.println("Please wait, we're already giving you a gumball");
        }
    }

··········    

    public void refill(int numGumballs){
        this.count = numGumballs;
        state = NO_QUARTER;
    }

    public String toString(){
        StringBuffer result = new StringBuffer();
        result.append("\nMighty Gumball, Inc.");
        result.append("\nJava-enabled Standing Gumball Model #2004\n");
        result.append("Inventory: " + count + " gumball");
        if (count != 1) {
            result.append("s");
        }
        result.append("\nMachine is ");
        if (state == SOLD_OUT) {
            result.append("sold out");
        } else if (state == NO_QUARTER) {
            result.append("waiting for quarter");
        } else if (state == HAS_QUARTER) {
            result.append("waiting for turn of crank");
        } else if (state == SOLD) {
            result.append("delivering a gumball");
        }
        result.append("\n");
        return result.toString();
    }
}

可以用下面的代码进行测试：

/**
 * @author Tianlong Zhang
 * @time 2018/9/3 10:39
 * @project DesignPattern
 * @Version 1.0.0
 */
public class GumballMachineTestDrive {
    public static void main(String[] args){
        GumballMachine gumballMachine = new GumballMachine(5);

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.ejectQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.ejectQuarter();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);
    }
}

此时，运行结果为：

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 5 gumballs
Machine is waiting for quarter

You insert a quarter
You turned...
A gumball comes rolling out the slot

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 4 gumballs
Machine is waiting for quarter

You insert a quarter
Quarter returned
You turned but there's no quarter

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 4 gumballs
Machine is waiting for quarter

You insert a quarter
You turned...
A gumball comes rolling out the slot
You insert a quarter
You turned...
A gumball comes rolling out the slot
You haven't inserted a quarter

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 2 gumballs
Machine is waiting for quarter

You insert a quarter
You can't insert another quarter
You turned...
A gumball comes rolling out the slot
You insert a quarter
You turned...
A gumball comes rolling out the slot
Oops, out of gumballs
You can't insert a quarter, the machine is sold out
You turned , but there are no gumballs

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 0 gumballs
Machine is sold out

然而当我们还是面对着老话题，躲不开的话题，需求更改时，这样的设计方式就会显得捉襟见肘：此时的糖果公司由于竞争，需要给糖果机增加一个功能，每购买糖果10次，就可以获得一次竞赛的机会，出售糖果状态下会有10%的概率掉下两个糖果，所以对照我们上面的设计，是不是需要改动很多呢，不仅仅需要改动与竞赛相关的代码，原有的每个动作代码了里面的逻辑过程也都需要修改，因为此时有加入了一个新的状态，如果事件允许的话，可以自行尝试以下，这里就不再赘述了。

但是当我们换一种思考方式，类似于类的成员函数等与这个类的关系，本质上，类是定义了一个物体，而成员函数则大部分情况下为定义的这个物体的相关的动作。我们可以类比推理过来，可以将每个状态单独封装称一个类，用这个类来管理，这样就可以方便的管理状态，同时i也放也方便这个代码的维护和扩充，让我们不再去修改每部分代码的逻辑，住去修改相关，添加或删除相关的逻辑代码就可以了。所以我们放弃维护之前写过的代码，重新重构一个按照上述过程的代码：

首先定义一个接口，它规范了糖果机的行为，定义如下：

/**
 * @author Tianlong Zhang
 * @time 2018/9/3 10:43
 * @project DesignPattern
 * @Version 1.0.0
 */
public interface State {
    public void insertQuarter();
    public void ejectQuarter();
    public void turnCrank();
    public void dispense();

    public void refill();
}

因为每个动作都会使得状态发生改变，所以我们需要对每个状态分开来管理，使得尽量一个类管理一个状态，这样我们分别构建类4个类：

以出售状态为例，继承定义的接口，实现行为，完成相关的逻辑：

**
 * @author Tianlong Zhang
 * @time 2018/9/3 10:45
 * @project DesignPattern
 * @Version 1.0.0
 */
public class SoldState implements State {
    GumballMachine gumballMachine;

    public SoldState(GumballMachine gumballMachine){
        this.gumballMachine = gumballMachine;
    }

    public void insertQuarter(){
        System.out.println("Please wait, we're already giving you a gumball");
    }

    public void ejectQuarter(){
        System.out.println("Sorry, you already turned the crank");
    }

    public void turnCrank(){
        System.out.println("Turning twice doesn't get you another gumball!");
    }

    public void dispense(){
        gumballMachine.releaseBall();
        if(gumballMachine.getCount() > 0){
            gumballMachine.setState(gumballMachine.getNoQuarterState());
        }else {
            System.out.println("Oops, out of gumballs");
            gumballMachine.setState(gumballMachine.getSoldOutState());
        }
    }

    public void refill(){

    }

    public String toString(){
        return "dispensing a gumball";
    }
}

类似的，根据业务的逻辑进行编写，分别完成4个状态：分别为：售罄（SoldOutState），没有投入25美分（NoQuarterState），投入了25美分（HasQuarterState），竞猜成功状态（WinnerState）。这里就不一样赘述，详细可以参考完整代码 GOGOGO。

编写一个测试类进行测试：

/**
 * @author Tianlong Zhang
 * @time 2018/9/3 14:53
 * @project DesignPattern
 * @Version 1.0.0
 */
public class GumballMachineTestDrive {
    public static void main(String[] args) {
        GumballMachine gumballMachine =
                new GumballMachine(10);

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

      ······
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);
    }
}

运行结果和上面的结果相同，但是不同的是，我们通过一个类来管理一个状态的设计方式更好的进行了松耦合，能够最大程度的保证了代码的弹性。但是增加了游戏的运行结果如下所示：

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 10 gumballs
Machine is waiting for quarter

You inserted a quarter
You turned...
A gumball comes rolling out the slot...
You inserted a quarter
You turned...
A gumball comes rolling out the slot...

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 8 gumballs
Machine is waiting for quarter

You inserted a quarter
You turned...
A gumball comes rolling out the slot...
You inserted a quarter
You turned...
A gumball comes rolling out the slot...

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 6 gumballs
Machine is waiting for quarter

You inserted a quarter
You turned...
A gumball comes rolling out the slot...
You inserted a quarter
You turned...
A gumball comes rolling out the slot...

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 4 gumballs
Machine is waiting for quarter

You inserted a quarter
You turned...
A gumball comes rolling out the slot...
You inserted a quarter
You turned...
A gumball comes rolling out the slot...

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 2 gumballs
Machine is waiting for quarter

You inserted a quarter
You turned...
A gumball comes rolling out the slot...
You inserted a quarter
You turned...
A gumball comes rolling out the slot...
Oops, out of gumballs!

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 0 gumballs
Machine is sold out

 

匍匐-菜鸟
关注
专栏目录
状态设计模式
Keiissland的博客
04-10 386
状态模式（State）是一种行为型设计模式。当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类。简单来说就是，一个含有多种状态的实例，其行为随状态的变化而变化。
设计模式-状态模式
qq_20967339的博客
05-20 521
状态模式以电梯为例子 电梯有哪些动作（映射到Java中就有多少方法）：开门、关门、运行、停止，就这四个动作，用程序来实现一下电梯的动作，先看类图设计： 非常简单的类图，定义一个接口，然后是一个实现类，然后业务类Client就可以调用，并运行起来，先看接口： package com.example.xpeng.statemode; /** * Created by xpeng on...
【设计模式】——状态模式（State Pattern）
最新发布
J^T的博客
08-06 594
状态模式（State Pattern）是一种重要的行为型设计模式，它允许一个对象在其内部状态改变时改变其行为，使得对象看起来像是改变了它的类。状态模式通过将状态相关的行为封装在独立的状态类中，有效地简化了条件逻辑，提高了代码的可维护性和可扩展性。
设计模式——状态模式
zhang33565417的博客
11-07 189
概述 状态模式：（State Pattern）允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类 状态模式主要解决的是当控制一个对象状态的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简化。 何时使用： 状态模式一般用来实现状态机，而状态机常用在游戏、工作流引擎等系统开发中。 代码中包含大量与对象状态有关的条件语句。 什么是状态机？ 状态机有 3 个组成部分：状态（State）、事件（Event）、动作（Action）。其中
【设计模式】状态
讲述工作、生活、技术中的日常与感悟。
08-17 140
状态模式介绍 状态模式是一种行为设计模式，让你能在一个对象的内部状态变化时改变其行为，使其看上去就像改变了自身所属的类一样。 状态模式描述的是一个行为下的多种状态变更，比如我们最常见的一个网站的页面，在你登录与不登录时，用户看到的页面是不同的，而这种登录与不登录就是我们通过改变状态而让整个行为发生了变化。 状态模式建议为对象的所有可能状态新建一个类，然后将所有状态的对应行为抽取到这些类中。 原始对象被称为上下文，它并不会自行实现所有行为，而是会保存一个指向表示当前状态对象的引用，且将所有与状态相关的工
Android编程设计模式之状态模式详解
01-21
本文实例讲述了Android编程设计模式之状态模式。分享给大家供大家参考，具体如下： 一、介绍 状态模式中的行为是由状态来决定的，不同的状态下有不同的行为。状态模式和策略模式的结构几乎完全一样，但它们的目的、...
Python设计模式之状态模式原理与用法详解
12-25
本文实例讲述了Python设计模式之状态模式原理与用法。分享给大家供大家参考，具体如下： 状态模式(State Pattern):当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类 下面是一个状态模式的...
设计模式之状态模式和观察者模式摘录
02-21
状态模式（State Pattern）和观察者模式（Observer Pattern）是软件开发中常用的两种设计模式，它们用于处理不同的设计问题和需求场景。在本文中，我们将重点探讨状态模式的设计意图、适用性、相关模式、以及与策略...
实用设计模式之状态模式
文斌咨询
03-17 4816
状态模式的针对性很强，当有状态变化的时候很多工程师会倾向于选择状态模式，但在使用时仍然存在着很多问题，比如状态的拆分不清晰、状态的变迁不准确、类的职责划分不单一等，一旦与具体的业务逻辑和已有的代码上下文放在一起，就出现了混乱。因此，本文以一个实际的例子来总结一下在现实当中如何使用状态模式。 1.什么是状态模式        状态模式(State Pattern)是设计模式的一种，属于行为模式。其定
设计模式：状态模式
imVainiycos的博客
11-27 506
在实际业务开发过程中，我们经常会遇到对应记录多种状态的变更和流转，一般情况下我们简单的可以用多个if来进行过程代码的编写，即if(状态符合){执行后续流程} if(状态不符合){return;}。但是实际上我们可以通过状态模式这一种较为巧妙的设计模式来达到我们的效果。 文章目录一、什么是状态模式二、模型分析三、模型实现四、总结 一、什么是状态模式 状态这个词汇我们并不陌生，在日常生活中，不同时间就有不同的状态，早上起来精神饱满，中午想睡觉，下午又渐渐恢复，晚上可能精神更旺也可能耗费体力只想睡觉，这一天中.
设计模式：状态设计模式
weixin_44251099的博客
05-25 411
状态设计模式的概念和作用状态设计模式是一种行为型设计模式，它可以有效地管理对象的状态，使对象在不同的状态下具有不同的行为和属性。状态设计模式将对象状态的转换和判断封装到不同的状态类中，从而提高代码的可扩展性和可维护性。状态设计模式是一种常用的行为型设计模式，可以有效地管理对象的状态，使对象在不同状态下具有不同的行为和属性。状态设计模式由状态接口、具体状态类和上下文类等组成部分，通过状态转换和状态判断等逻辑实现状态的变化和行为的变化。
设计模式之状态模式详解
glass__sky的博客
06-10 3570
【例】通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。...
设计模式系列之「状态模式」
Young的博客
09-22 460
设计模式系列之「状态模式」
JavaScript设计模式：状态模式实例详解
"深入理解JavaScript系列（43）：设计模式之状态模式详解"这一篇文章详细探讨了JavaScript中的状态模式，这是一种行为设计模式，主要用于解决对象在不同状态下表现出不同行为的问题。状态模式的核心理念是将对象的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值