行为型设计模式之状态模式（State）

最新推荐文章于 2024-04-03 18:59:16 发布
最新推荐文章于 2024-04-03 18:59:16 发布
阅读量180 收藏
点赞数
分类专栏： Java设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/benchi400/article/details/106175406
版权

设计模式之状态模式

这里我们用汽车的运动过程来作为一个示例讲解，首先看一段最初始的代码：

public class State_01 {

    static class Car {
    
        public void start() {
            System.out.println("============启动==========");
        }

        public void run() {
            System.out.println("============行驶==========");
        }

        public void stop() {
            System.out.println("============停止==========");
        }

        public void openDoor() {
            System.out.println("============开门==========");
        }

        public void closeDoor() {
            System.out.println("============关门==========");
        }
    }
}

如上代码，假设汽车状态切换：门关闭状态->门打开状态->启动状态->运行状态->停止状态，在状态切换时，有些行为是不能发生的，所以要做限制，下面按照上面车辆状态切换，来重构以上代码：

public class State_02 {

    static class Car {

        public static final int state_start = 1;
        public static final int state_run = 2;
        public static final int state_stop = 3;
        public static final int state_open = 4;
        public static final int state_close = 5;
        private int state;//当前状态

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

        public void start() {
            switch (this.state){
                case state_start:break;
                case state_run:break;
                case state_stop:
                    this.startActive();
                    this.setState(state_start);
                    break;
                case state_open:break;
                case state_close:
                    this.startActive();
                    this.setState(state_start);
                    break;
                default: break;
            }
        }

        public void run() {
            switch (this.state){
                case state_start:
                    this.runActive();
                    this.setState(state_run);
                    break;
                case state_run:break;
                case state_stop:
                    this.runActive();
                    this.setState(state_run);
                    break;
                case state_open:break;
                case state_close:break;
                default: break;
            }
        }

        public void stop() {
            switch (this.state){
                case state_start:break;
                case state_run:
                    this.stopActive();
                    this.setState(state_stop);
                    break;
                case state_stop:break;
                case state_open:break;
                case state_close:break;
                default: break;
            }
        }

        public void openDoor() {
            switch (this.state){
                case state_start:break;
                case state_run:break;
                case state_stop:break;
                case state_open:break;
                case state_close:
                    this.openDoorActive();
                    this.setState(state_open);
                    break;
                default: break;
            }
        }

        public void closeDoor() {
            switch (this.state){
                case state_start:
                    break;
                case state_run:break;
                case state_stop:
                    break;
                case state_open:
                    this.closeDoorActive();
                    this.setState(state_close);
                    break;
                case state_close:
                    break;
                default: break;
            }
        }

        private void startActive() {
            System.out.println("============启动==========");
        }

        private void runActive() {
            System.out.println("============行驶==========");
        }

        private void stopActive() {
            System.out.println("============停止==========");
        }

        private void openDoorActive() {
            System.out.println("============开门==========");
        }

        private void closeDoorActive() {
            System.out.println("============关门==========");
        }
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.setState(Car.state_close);
        car.openDoor();
        car.closeDoor();
        car.start();
        car.run();
        car.stop();
    }
}

以上代码的逻辑就是，一开始车门处于关闭状态，这时候可以执行开启车门操作，变为开启状态，然后执行关闭车门操作，变为关闭车门状态，在关闭车门状态下，可以启动汽车，状态变为启动，然后就是行驶，到停止，这就是整个流程。

虽然已经实现功能，但是从以上代码可以知道，这部门代码每个状态切换的方法里面都包含了switch分支，代码显得冗余，尤其如果有新的状态加入，每个switch都要新增一个状态的判断分支，改动过大，所以需要对其进行优化。

就是对状态进行抽象，然后创建子类状态，每个状态类里面都写入各自状态对应的逻辑即可，如下：

public class State_03 {

    static abstract class AbstractState{
        private Context context;

        public void setContext(Context context) {
            this.context = context;
        }

        public abstract void start();

        public abstract void run();

        public abstract void stop();

        public abstract void open();

        public abstract void close();

    }

    static class Context{
        public static final AbstractState startState = new StartState();
        public static final AbstractState runState = new RunState();
        public static final AbstractState stopState = new StopState();
        public static final AbstractState openState = new OpenState();
        public static final AbstractState closeState = new CloseState();

        private AbstractState state;

        public AbstractState getState() {
            return state;
        }

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

        public void start(){
            state.start();
        }

        public void run(){
            state.run();
        }

        public void stop(){
            state.stop();
        }

        public void open(){
            state.open();
        }

        public void close(){
            state.close();
        }
    }

    //启动状态
    static class StartState extends AbstractState{
        @Override
        public void start() {
            System.out.println("================启动================");
        }

        @Override
        public void run() {
            super.context.setState(Context.runState);
            super.context.getState().run();
        }

        @Override
        public void stop() {
            super.context.setState(Context.stopState);
            super.context.getState().stop();
        }

        @Override
        public void open() {

        }

        @Override
        public void close() {

        }
    }

    //行驶状态
    static class RunState extends AbstractState{
        @Override
        public void start() {

        }

        @Override
        public void run() {
            System.out.println("================运行================");
        }

        @Override
        public void stop() {
            super.context.setState(Context.stopState);
            super.context.getState().stop();
        }

        @Override
        public void open() {

        }

        @Override
        public void close() {

        }
    }

    //停止状态
    static class StopState extends AbstractState{
        @Override
        public void start() {
            super.context.setState(Context.startState);
            super.context.getState().start();
        }

        @Override
        public void run() {

        }

        @Override
        public void stop() {
            System.out.println("===============停止===============");
        }

        @Override
        public void open() {

        }

        @Override
        public void close() {

        }
    }

    //开门状态
    static class OpenState extends AbstractState{
        @Override
        public void start() {

        }

        @Override
        public void run() {

        }

        @Override
        public void stop() {

        }

        @Override
        public void open() {
            System.out.println("================开门=================");
        }

        @Override
        public void close() {
            super.context.setState(Context.closeState);
            super.context.getState().close();
        }
    }

    //启动状态
    static class CloseState extends AbstractState{
        @Override
        public void start() {
            super.context.setState(Context.startState);
            super.context.getState().start();
        }

        @Override
        public void run() {

        }

        @Override
        public void stop() {

        }

        @Override
        public void open() {
            super.context.setState(Context.openState);
            super.context.getState().open();
        }

        @Override
        public void close() {
            System.out.println("================关门=================");
        }
    }

    public static void main(String[] args) {
        Context context = new Context();
        context.setState(Context.closeState);
        context.open();
        context.close();
        context.start();
        context.run();
        context.stop();
    }
}

以上代码主要做了一下动作：

  1. 抽象出状态类，以及抽象方法和依赖的环境类Context（具体调用类）。
  2. 创建一个环境类Context，内部的方法和抽象状态类一样，且可以设置当前状态，在每个方法内部，都是调用当前状态的对应方法。
  3. 实现多个具体的状态类，每个状态类都有具体执行动作方法，以及实现该状态下可以切换到哪些状态方法体，并委托给Context来执行。

以上就是状态模式的一个简单的演变过程，官方对状态模式定义：当一个对象内置状态改变时允许其改变行为，这个对象看起来像改变了其类。

状态模式的优点：

  1. 编码了过多的switch…case或者if…else语句，降低了程序的复杂性，提高了系统可维护性；
  2. 遵循设计原则，开闭原则和单一职责原则。
  3. 封装性好

状态模式的缺点：

状态太多的情况，就会导致子类过多（类膨胀）

fq_winer_123
关注
专栏目录
Java行为型设计模式-状态模式（含电梯场景示例）
欢迎拜读我的作品，喜欢的领域请给我留言
08-24 993
状态模式）是一种行为型设计模式，它允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。状态模式的目的是让状态转换显式，并且使得状态转换代码集中在一个地方，不需要使用多重条件语句。状态模式）用于解决系统中对象的行为依赖于其状态变化的问题。在状态模式中，我们将每一个状态转换到另一个状态的行为封装在一个状态类中。综上，状态模式（State Pattern）允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。状态模式的目的是让状态转换显式。
关于Java中public static final int用法解答
迪迦 • 奥特曼
03-31 1666
public class FinalOriginalTest { private final int a; private String name; public FinalOriginalTest(){ a = 3; } public FinalOriginalTest(String name){ ...
1.定义一个Computer类，有属性private int state 表示为状态码，有2个方法，一个是run()方法，当state 为1时,在方法里正常显示“电脑成功运行”，当state 为2..
davaid21的博客
07-16 597
import java.util.Scanner; class LanPIngException extends Exception { public LanPIngException() { } public LanPIngException(String message) { super(message); } } class MaoYanException extends Exception { public MaoYanExceptio.
Android Gallery 3D 特效精华
秋风的博客
10-25 3908
Android Gallery 3D 特效精华   一、布局  gallery3d 的界面生成和普通的应用程序不一样。普通程序一般一个界面就是一  个activity,布局用xml或代码都可以实现，界面切换是activity 的切换方式；  而 gallery3d没有用android 的UI 系统，而是用opengl 画出来的,即界面是在  同一个 activity 的，如主界
【Java 设计模式】行为型之状态模式
好久不见的流星
01-24 1375
状态模式是一种行为型设计模式，用于通过将对象的行为封装到不同的状态类中，使得对象在不同的状态下具有不同的行为。状态模式允许对象在内部状态发生改变时改变其行为，而无需修改其代码。状态模式通常包含三个主要角色：上下文（Context）、抽象状态（Abstract State）和具体状态（Concrete State）。定义了一个接口，用于维护一个当前状态的引用，并提供一个用于切换状态的方法定义了一个接口，用于封装与上下文相关的一个或多个行为实现了抽象状态的接口，负责处理与状态相关的行为。
设计模式 - 行为型设计模式 - 状态模式（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...
设计模式之状态模式(行为型)
Nicky's blog
12-23 3406
模式定义 一个对象在其内部状态改变时改变其行为，这个对象我们可以称为状态对象，所以状态模式是一种对象行为型模式。 模式结构 Context：环境类 Context类也可以称之为上下文类，实际上就是拥有状态的对象，可以理解为状态管理器。 State：抽象状态类 抽象状态类可以是一个接口类或者抽象类，反正实现的话都是通过具体状态类。抽象状态类，封装环境类不同状态下的所有动作方法。 Conc...
设计模式｜状态机模式（State Machine Pattern）
weixin_44435110的博客
04-03 5497
状态机模式（State Machine Pattern）是一种用于描述对象的行为软件设计模式，属于行为型设计模式。在状态机模式中，对象的行为取决于其内部状态，并且在不同的状态下，对象可能会有不同的行为。
设计模式行为型——状态模式
tszc95的博客
08-07 2341
状态模式（State Pattern）属于行为型设计模，也叫作状态机模式（StateMachine Pattern），对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。状态模式中类的行为是由状态决定的，在不同的状态下有不同的行为。其意图是让一个对象在其内部改变的时候，行为也随之改变。状态模式的核心是状态与行为绑定，不同的状态对应不同的行为。
C++设计模式之状态模式(state)(行为型)
janeqi1987的专栏
01-18 3528
一 定义 状态模式：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。 状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂的情况。把不同状态的操作分散到不同的状态对象里去完成。在很多情况下，一个对象的行为取决于一个或多个动态变化的属性，这样的属性叫做状态，这样的对象叫做有状态的(stateful)对象，这样的对象状态是从事先定义好的一系列值中取出的。当一个这样...
设计模式之11个行为型模式
02-24
行为型简介职责链模式(ChainofResponsibility)命令模式(Command)解释器模式(Interpreter)迭代器模式(Iterator)中介者模式(Mediator)备忘录模式(Memento)观察者模式(Observer)状态模式(State)策略模式(Strategy)模板...
java 设计模式之State(状态模式）
08-29
Java 设计模式之 State（状态模式）是行为型模式之一，主要解决的问题是当一个对象的行为取决于它的状态，并且它需要在运行时刻根据不同的状态对其行为进行改变时，如何对其进行设计和实现。 State 模式的定义 ...
Java设计模式之状态模式（State模式）介绍
09-03
状态模式是一种行为设计模式，它允许对象在内部状态改变时改变其行为，使对象看起来好像修改了它的类。在Java中，状态模式通常用于将状态相关的逻辑从对象主体中分离出来，使得对象的行为可以根据其状态动态地更新。...
状态模式（State Pattern）是一种行为设计模式
05-27
状态模式（State Pattern）是一种行为设计模式，它允许对象在内部状态改变时改变其行为，对象看起来似乎修改了它的类。这种模式将一个对象的行为分解为各个独立的状态，并且每个状态都封装在自己的类中，使得对象在...
设计模式C++学习之状态模式（State）
09-07
状态模式是一种行为设计模式，它允许对象在内部状态改变时改变其行为，对象看起来似乎修改了它的类。这种模式常用于处理对象的状态变化，并且使代码结构清晰，易于维护。 在C++中，状态模式通常包含以下几个关键...
C# winform使用纯opencvsharp部署yolov11-onnx图像分类模型源码
10-06
【测试环境】 vs2019 net framework4.7.2 opencvsharp4.8.0 【视频演示】 https://www.bilibili.com/video/BV1EB1iYXEoi/ 【博文地址】 https://blog.csdn.net/FL1623863129/article/details/142728931
现代密码学课程实验.zip
10-06
项目学习分享。【项目资源】：包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源、音视频、网站开发等各种技术项目的源码。包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。 【技术】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
2022人工智能技术创新大赛-赛道1-电商关键属性匹配.zip
最新发布
10-06
项目学习分享。【项目资源】：包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源、音视频、网站开发等各种技术项目的源码。包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。 【技术】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
基于ssm大学图书管理系统.zip
10-06
基于ssm大学图书管理系统 食物管理.. 运动管理 用户管理 Android端 手机登陆 手机注册… 手机功能选择 个人健康信息 食物计算器、 生活记录本
行为型模式：11种经典设计模式详解
行为型模式是软件设计模式的一种，它主要关注对象之间的交互和动态行为，而非仅仅局限于类和对象的静态结构。这些模式解决的是如何在对象之间划分责任和算法，使得系统的运行更加灵活和高效。 1. 职责链模式（Chain...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值