行为型模式-状态模式

状态模式

概述

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

类图如下：

在这里插入图片描述

代码如下：

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也是一样)，使程序的可阅读性变差。
  • 扩展性很差。如果新加了断电的状态，我们需要修改上面判断逻辑

定义：

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

结构

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

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

案例实现

对上述电梯的案例使用状态模式进行改进。类图如下：

在这里插入图片描述

代码如下：

//抽象状态类
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();
    }
}

优缺点

1，优点：

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

2，缺点：

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

使用场景

  • 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
  • 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/17930.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

MySQL

MySQL

关系型数据库 数据结构：二维表格 库 -> 表 -> 列（字段）：用来描述对象的一个属性 -> 行（记录）：用来描述一个对象的信息 市面上：MySQL 、Mariadb 、PostgreSQL 、 Oracle&a…
阅读更多...
汽车电路图、原理框图、线束图、元器件布置图的识读技巧与要点

汽车电路图、原理框图、线束图、元器件布置图的识读技巧与要点

摘要： 想要读懂汽车电路图就必须把电的通路理清楚，即某条线是什么信号，该信号是输入信号、输出信号还是控制信号以及信号起什么作用，在什么条件下有信号，从哪里来，到哪里去。 一、汽车电路图的识读技巧 1.…
阅读更多...
在 Python 中将 Tqdm 与 Asyncio 结合使用

在 Python 中将 Tqdm 与 Asyncio 结合使用

动动发财的小手，点个赞吧！ 简介 困扰 在 Python 中使用并发编程来提高效率对于数据科学家来说并不罕见。在后台观察各种子进程或并发线程以保持我的计算或 IO 绑定任务的顺序总是令人满意的。 但是还有一点困扰我的是，当我在后台并发处理成百…
阅读更多...
PBDB Data Service：Thumbnail images of lifeforms（生命形式的缩略图）

PBDB Data Service：Thumbnail images of lifeforms（生命形式的缩略图）

Thumbnail images of lifeforms（生命形式的缩略图） 描述用法参数方法响应值格式术语表 描述 此操作返回表示指定分类的图像，或关于图像的信息。如果后缀是 .png，则返回图像内容数据。否则，将以指定的格式返回一个描述…
阅读更多...
9:00进去，9:05就出来了，这问的也太···

9:00进去，9:05就出来了，这问的也太···

从外包出来，没想到死在另一家厂子了。 自从加入这家公司，每天都在加班，钱倒是给的不少，所以也就忍了。没想到8月一纸通知，所有人不许加班，薪资直降30%，顿时有吃不起饭的赶脚。 好在有个兄弟内推…
阅读更多...
【Halcon】新建程序 读取图片 路径设置

【Halcon】新建程序 读取图片 路径设置

文章目录 1 新建程序2 读取一张图片3 图片路径4 图片格式读取报错5 快速添加 绝对路径1 新建程序 点击新程序图标，即可新建； 程序另存为，会弹出保存路径 2 读取一张图片 read_image(Image,fabrik)
阅读更多...
软件测试工程师的核心竞争力究竟是什么？

软件测试工程师的核心竞争力究竟是什么？

对于测试员而言，了解自己岗位的核心竞争力是非常重要的。在职业初期，许多人认为掌握代码才是软件测试的核心竞争力，但是随着经验的增加，我们会发现真正的核心竞争力是由多个方面组成的。 首先，测试人员需要具备良好的测…
阅读更多...
Windows环境安装Elasticsearch和Kibana

Windows环境安装Elasticsearch和Kibana

文章目录 1 Elasticsearch1.1 下载1.2 解压并添加环境变量1.3 访问1.4 cmd命令1.5 中文分词器1.5.1 下载1.5.2 安装1.5.2.1 命令安装1.5.2.2 手动安装1.5.2.3 验证分词 1.6 使用curl批量导入 2 安装 kibana2.1 下载kibana2.2 中文界面2.3 操作索引2.3.1 增加索引2.3.1.1 单条新…
阅读更多...
Apache Doris学习记录

Apache Doris学习记录

1. Doris基础学习 中文官网:https://doris.apache.org/zh-CN/docs/dev/summary/basic-summary/ 1.1 doris 简介 Apache Doris 是一个现代化的 MPP(Massively Parallel Processing，即大规模并行处理) 分析型数据库产品 亚秒级响应时间即可获得查询结果 可以支持 10PB…
阅读更多...
紧急下架，AI以假乱真学明星唱歌；哈佛法学院专家谈AI和版权法

紧急下架，AI以假乱真学明星唱歌；哈佛法学院专家谈AI和版权法

几周前，一首据称由 Drake 和 The Weeknd 创作的新歌登陆 TikTok 和 Spotify，并迅速在互联网上像野火一样传播开来。“我袖子上的心”在嘻哈乐迷中获得了好评如潮和高度兴奋，这不仅是因为该曲目具有感染力的歌词和旋律，而且还因为对…
阅读更多...
jieba分词（1）：入门案例

jieba分词（1）：入门案例

1 场景介绍 大数据量的查询问题 假设我们要从商品的表里面查询一个商品 我们的数据库里面肯定有个t_goods的表，我们现在利用商品的名称做模糊查询 1.1 对于数据库的查询的 select * from t_goods where goodsName like “%手机%” ; 问题： 这个查询…
阅读更多...
开关电源基础01：电源变换器基础（2）

开关电源基础01：电源变换器基础（2）

说在开头：关于德布罗意的电子波（3） 1923年，德布罗意在求出他的相波之前，康普顿刚好用光子说解释了康普顿效应（记性好的胖友们应该还记得：散射波的波长变长问题），从而带领…
阅读更多...
SPSS如何进行聚类分析之案例实训？

SPSS如何进行聚类分析之案例实训？

文章目录 0.引言1.快速聚类分析2.分层聚类分析3.两阶段聚类分析 0.引言 因科研等多场景需要进行数据统计分析，笔者对SPSS进行了学习，本文通过《SPSS统计分析从入门到精通》及其配套素材结合网上相关资料进行学习笔记总结，本文对聚类分析进行阐…
阅读更多...
[架构之路-187]-《软考-系统分析师》-5-数据库系统 - 操作型数据库OLTP与分析型数据库OLAP比较

[架构之路-187]-《软考-系统分析师》-5-数据库系统 - 操作型数据库OLTP与分析型数据库OLAP比较

OLAP与OLTP的区别？ OLTP(Online transaction processing) 在线/联机事务处理。典型的OLTP类操作都比较简单，主要是对数据库中的数据进行增删改查，操作主体一般是产品的用户。 OLAP(Online analytical processing): 指联机分析处理。通过分…
阅读更多...
SPSS如何进行判别分析之案例实训？

SPSS如何进行判别分析之案例实训？

文章目录 0.引言1.一般判别分析2.逐步判别分析3.决策树分析 0.引言 因科研等多场景需要进行数据统计分析，笔者对SPSS进行了学习，本文通过《SPSS统计分析从入门到精通》及其配套素材结合网上相关资料进行学习笔记总结，本文对判别分析进行阐述。…
阅读更多...
类和对象（上）

类和对象（上）

文章目录 1.面向过程和面向对象初步认识2.类的引入3.类的定义3.1声明和定义全部放在类体3.2.声明放在.h，定义放在.cpp 4..类的访问限定符及封装4.1封装4.2访问限定符4.3C中的struct和class 5.类的作用域6.类的实例化6.1引入6.2定义 7.类对象模型7.1类对象的存储方式…
阅读更多...
MySQL知识学习06（SQL语句在MySQL中的执行过程）

MySQL知识学习06（SQL语句在MySQL中的执行过程）

1、MySQL 基本架构概览 下图是 MySQL 的一个简要架构图，从下图可以很清晰的看到用户的 SQL 语句在 MySQL 内部是如何执行的。 先简单介绍一下下图涉及的一些组件的基本作用帮助大家理解这幅图 连接器： 身份认证和权限相关(登录 MySQL 的时候)。查询缓…
阅读更多...
Java设计模式-代理模式

Java设计模式-代理模式

简介 代理模式是一种结构型设计模式，它可以让我们通过一个代理对象来访问一个真实的目标对象，从而实现对目标对象的功能扩展或保护。代理模式的主要角色有三个： 抽象主题（Subject）：定义了真实主题和代理主…
阅读更多...
【Mybatis】增删改查

【Mybatis】增删改查

1.添加相应的jar包 2.创建持久化类 在src目录下创建一个名为com.mybatis.po的包 创建持久化类MyUser,包含三个属性（uid,uname,usex) package com.mybatis.po; /***springtest数据库中user表的持久化类*/ public class MyUser {private Integer uid;//主键private…
阅读更多...
OpenGL（六）——坐标系统

OpenGL（六）——坐标系统

目录 一、前言 二、空间系 2.1 局部空间 2.2 世界空间 2.3 观察空间 2.4裁剪空间 2.5 正射投影 2.6 透视投影 2.7 屏幕空间 三、透视箱子 3.1 创建模型矩阵 3.2 创建观察矩阵 3.3 创建透视投影矩阵 3.4 修改顶点着色器 3.5 传递变换矩阵 四、旋转的箱子 五、好…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发