Java状态模式电梯例子_设计模式C++实现—State状态模式（对象行为型）

最新推荐文章于 2022-08-31 18:47:56 发布
最新推荐文章于 2022-08-31 18:47:56 发布
阅读量153 收藏
点赞数 1
文章标签： Java状态模式电梯例子
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_29827071/article/details/114922554
版权

a4c26d1e5885305701be709a3d33442f.png

6.模式的组成

环境类(Context):

定义客户感兴趣的接口。维护一个ConcreteState子类的实例，这个实例定义当前状态。

抽象状态类(State):定义一个接口以封装与Context的一个特定状态相关的行为。

具体状态类(ConcreteState):每一子类实现一个与Context的一个状态相关的行为。

7. 实例

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

main()，客户

CLiftState，电梯状态抽象类

CCloseingState，电梯门关闭

COpenningState，电梯门打开

CRunningState，电梯运行

CStoppingState，电梯停止

CContext，电梯的控制面板

说明：CContext保持电梯的状态，并提供操作的接口函数。当函数被调用时，CContext直接调用当前状态的相应函数。由状态的接口函数来确定是否可以执行这个动作，以及修改状态为执行这个动作后的状态。

看代码：第一块是不使用模式的做法，第二块是使用模式的做法，在main()函数里会有调用的方式。

//ILift.h

#pragma once

class ILift

{

public:

ILift(void)

{

}

virtual

~ILift(void)

{

}

static

const int OPENING_STATE = 1;

static

const int CLOSING_STATE = 2;

static

const int RUNNING_STATE = 3;

static

const int STOPPING_STATE = 4;

virtual

void SetState(int state) = 0;

virtual

void Open() = 0;

virtual

void Close() = 0;

virtual

void Run() = 0;

virtual

void Stop() = 0;

};

//Lift.h

#pragma once

#include "ilift.h"

class CLift :

public

ILift

{

public:

CLift(void);

~CLift(void);

void

SetState(int state);

void

Open();

void

Close();

void

Run();

void

Stop();

private:

int

m_state;

void

OpenWithoutLogic();

void

CloseWithoutLogic();

void

RunWithoutLogic();

void

StopWithoutLogic();

};

//Lift.cpp

#include "StdAfx.h"

#include "Lift.h"

#include

using std::cout;

using std::endl;

CLift::CLift(void)

{

this->m_state = 0;

}

CLift::~CLift(void)

{

}

void CLift::SetState(int

state)

{

this->m_state = state;

}

void CLift::Open()

{

switch(this->m_state)

{

case

OPENING_STATE:

break;

case

CLOSING_STATE:

this->OpenWithoutLogic();

this->SetState(OPENING_STATE);

break;

case

RUNNING_STATE:

break;

case

STOPPING_STATE:

this->OpenWithoutLogic();

this->SetState(OPENING_STATE);

break;

}

}

void CLift::Close()

{

switch(this->m_state)

{

case

OPENING_STATE:

this->CloseWithoutLogic();

this->SetState(CLOSING_STATE);

break;

case

CLOSING_STATE:

break;

case

RUNNING_STATE:

break;

case

STOPPING_STATE:

break;

}

}

void CLift::Run()

{

switch(this->m_state)

{

case

OPENING_STATE:

break;

case

CLOSING_STATE:

this->RunWithoutLogic();

this->SetState(RUNNING_STATE);

break;

case

RUNNING_STATE:

break;

case

STOPPING_STATE:

this->RunWithoutLogic();

this->SetState(RUNNING_STATE);

break;

}

}

void CLift::Stop()

{

switch(this->m_state)

{

case

OPENING_STATE:

break;

case

CLOSING_STATE:

this->StopWithoutLogic();

this->SetState(CLOSING_STATE);

break;

case

RUNNING_STATE:

this->StopWithoutLogic();

this->SetState(CLOSING_STATE);

break;

case

STOPPING_STATE:

break;

}

}

void CLift::OpenWithoutLogic()

{

cout

<< "电梯门开启..." << endl;

}

void

CLift::CloseWithoutLogic()

{

cout

<< "电梯门关闭..." << endl;

}

void CLift::RunWithoutLogic()

{

cout

<< "电梯上下跑起来..." << endl;

}

void CLift::StopWithoutLogic()

{

cout

<< "电梯停止了..." << endl;

}

//LiftState.h

#pragma once

class CContext;

class CLiftState

{

public:

CLiftState(void);

virtual

~CLiftState(void);

void

SetContext(CContext *pContext);

virtual

void Open() = 0;

virtual

void Close() = 0;

virtual

void Run() = 0;

virtual

void Stop() = 0;

protected:

CContext

*m_pContext;

};

//LiftState.cpp

#include "StdAfx.h"

#include "LiftState.h"

CLiftState::CLiftState(void)

{

}

CLiftState::~CLiftState(void)

{

}

void CLiftState::SetContext( CContext *pContext

)

{

m_pContext

= pContext;

}

//CloseingState.h

#pragma once

#include "liftstate.h"

class CCloseingState :

public

CLiftState

{

public:

CCloseingState(void);

~CCloseingState(void);

void

Open();

void

Close();

void

Run();

void

Stop();

};

//CloseingState.cpp

#include "StdAfx.h"

#include "CloseingState.h"

#include "Context.h"

#include

using std::cout;

using std::endl;

CCloseingState::CCloseingState(void)

{

}

CCloseingState::~CCloseingState(void)

{

}

void CCloseingState::Open()

{

this->CLiftState::m_pContext->SetLiftState(CContext::pOpenningState);

this->CLiftState::m_pContext->GetLiftState()->Open();

}

void CCloseingState::Close()

{

cout

<< "电梯门关闭..." << endl;

}

void CCloseingState::Run()

{

this->CLiftState::m_pContext->SetLiftState(CContext::pRunningState);

this->CLiftState::m_pContext->GetLiftState()->Run();

}

void CCloseingState::Stop()

{

this->CLiftState::m_pContext->SetLiftState(CContext::pStoppingState);

this->CLiftState::m_pContext->GetLiftState()->Stop();

}

//OpenningState.h

#pragma once

#include "liftstate.h"

class COpenningState :

public

CLiftState

{

public:

COpenningState(void);

~COpenningState(void);

void

Open();

void

Close();

void

Run();

void

Stop();

};

//OpenningState.cpp

#include "StdAfx.h"

#include "OpenningState.h"

#include "Context.h"

#include

using std::cout;

using std::endl;

COpenningState::COpenningState(void)

{

}

COpenningState::~COpenningState(void)

{

}

void COpenningState::Open()

{

cout

<< "电梯门开启..." << endl;

}

void COpenningState::Close()

{

this->CLiftState::m_pContext->SetLiftState(CContext::pCloseingState);

this->CLiftState::m_pContext->GetLiftState()->Close();

}

void COpenningState::Run()

{

//do

nothing

}

void COpenningState::Stop()

{

//do

nothing

}

//RunningState.h

#pragma once

#include "liftstate.h"

class CRunningState :

public

CLiftState

{

public:

CRunningState(void);

~CRunningState(void);

void

Open();

void

Close();

void

Run();

void

Stop();

};

//RunningState.cpp

#include "StdAfx.h"

#include "RunningState.h"

#include "Context.h"

#include

using std::cout;

using std::endl;

CRunningState::CRunningState(void)

{

}

CRunningState::~CRunningState(void)

{

}

void CRunningState::Open()

{

//do

nothing

}

void CRunningState::Close()

{

//do

nothing

}

void CRunningState::Run()

{

cout

<< "电梯上下跑..." << endl;

}

void CRunningState::Stop()

{

this->CLiftState::m_pContext->SetLiftState(CContext::pStoppingState);

this->CLiftState::m_pContext->GetLiftState()->Stop();

}

//StoppingState.h

#pragma once

#include "liftstate.h"

class CStoppingState :

public

CLiftState

{

public:

CStoppingState(void);

~CStoppingState(void);

void

Open();

void

Close();

void

Run();

void

Stop();

};

//StoppingState.cpp

#include "StdAfx.h"

#include "StoppingState.h"

#include "Context.h"

#include

using std::cout;

using std::endl;

CStoppingState::CStoppingState(void)

{

}

CStoppingState::~CStoppingState(void)

{

}

void CStoppingState::Open()

{

this->CLiftState::m_pContext->SetLiftState(CContext::pOpenningState);

this->CLiftState::m_pContext->GetLiftState()->Open();

}

void CStoppingState::Close()

{

//do

nothing

}

void CStoppingState::Run()

{

this->CLiftState::m_pContext->SetLiftState(CContext::pRunningState);

this->CLiftState::m_pContext->GetLiftState()->Run();

}

void CStoppingState::Stop()

{

cout

<< "电梯停止了..." << endl;

}

//Contex.h

#pragma once

#include "LiftState.h"

#include "OpenningState.h"

#include "CloseingState.h"

#include "RunningState.h"

#include "StoppingState.h"

class CContext

{

public:

CContext(void);

~CContext(void);

static

COpenningState *pOpenningState;

static

CCloseingState *pCloseingState;

static

CRunningState *pRunningState;

static

CStoppingState *pStoppingState;

CLiftState

* GetLiftState();

void

SetLiftState(CLiftState *pLiftState);

void

Open();

void

Close();

void

Run();

void

Stop();

private:

CLiftState

*m_pLiftState;

};

//Context.cpp

#include "StdAfx.h"

#include "Context.h"

COpenningState* CContext::pOpenningState =

NULL;

CCloseingState* CContext::pCloseingState =

NULL;

CRunningState* CContext::pRunningState =

NULL;

CStoppingState* CContext::pStoppingState =

NULL;

CContext::CContext(void)

{

m_pLiftState = NULL;

pOpenningState = new COpenningState();

pCloseingState = new CCloseingState();

pRunningState = new CRunningState();

pStoppingState = new CStoppingState();

}

CContext::~CContext(void)

{

delete

pOpenningState;

pOpenningState = NULL;

delete

pCloseingState;

pCloseingState = NULL;

delete

pRunningState;

pRunningState = NULL;

delete

pStoppingState;

pStoppingState = NULL;

}

CLiftState *

CContext::GetLiftState()

{

return

m_pLiftState;

}

void CContext::SetLiftState(CLiftState

*pLiftState)

{

this->m_pLiftState = pLiftState;

this->m_pLiftState->SetContext(this);

}

void CContext::Open()

{

this->m_pLiftState->Open();

}

void CContext::Close()

{

this->m_pLiftState->Close();

}

void CContext::Run()

{

this->m_pLiftState->Run();

}

void CContext::Stop()

{

this->m_pLiftState->Stop();

}

// State.cpp : 定义控制台应用程序的入口点。

#include "stdafx.h"

#include "ILift.h"

#include "Lift.h"

#include "Context.h"

#include "OpenningState.h"

#include "CloseingState.h"

#include "RunningState.h"

#include "StoppingState.h"

#include

using std::cout;

using std::endl;

void DoIt()

{

//ILift.h,

Lift.h, Lift.cpp

ILift

*pLift = new CLift();

pLift->SetState(ILift::STOPPING_STATE);//电梯的初始条件是停止状态。

pLift->Open();//首先是电梯门开启，人进去

pLift->Close();//然后电梯门关闭

pLift->Run();//再然后，电梯跑起来，向上或者向下

pLift->Stop();//最后到达目的地，电梯停下来

delete

pLift;

}

void DoNew()

{

//LiftState.h, LiftState.cpp, OpenningState.h, CloseingState.h,

RunningState.h, StoppingState.h

//Context.h, Context.cpp

CContext

context;

CCloseingState closeingState;

context.SetLiftState(&closeingState);

context.Close();

context.Open();

context.Run();

context.Stop();

}

int _tmain(int argc, _TCHAR*

argv[])

{

cout

<< "----------使用模式之前----------" <<

endl;

DoIt();

cout

<< "----------使用模式之后----------" <<

endl;

DoNew();

_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF |

_CRTDBG_ALLOC_MEM_DF);

_CrtDumpMemoryLeaks();

return

0;

}

系统领航员
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
设计模式，状态模式：电梯先关门后移动，c++实现
ganfanren00001的博客
10-17 574
状态模式：电梯想要移动首先得是关门的。 定义：当一个对象内在状态改变时，允许其改变行为，这个对象看起来像改变了其类。 翻译：就是没有某个状态，就不能做出某行为。因为类的动作一般是在任何情况下都可以调用的，受到状态的限制后，就像是基于不同的状态而换了不同的类一样，对着状态机理解就可。 类图摘自设计模式之禅： state抽象状态角色，接口或抽象类： 负责对象状态定义，封装环境角色以实现状态切换。 封装对象的所有功能函数，已满足实现不同的状态。 concretestate具体状态角色，两个职责： 本状态的行为管
设计模式C++学习笔记之十九（State状态模式）
weixin_30519071的博客
04-21 82
19.1.解释 概念：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。 main()，客户 CLiftState，电梯状态抽象类 CCloseingState，电梯门关闭 COpenningState，电梯门打开 CRunningState，电梯运行 CStoppingState，电梯停止 CContext，电梯的控制面板 说明：CContext保持电梯的...
状态模式模拟电梯运行
pattyi的博客
11-18 568
public abstract class State { public abstract void open(); public abstract void close(); public abstract void run(); public abstract void stop(); } public class RunState extends State{ Context context; public RunState(Context con.
java面向对象思维程序设计开发以及案例 -电梯运行问题对象分析与程序设计(2)
峡谷电光马仔的博客
08-31 1515
电梯是我们日常生活中经常看见和使用的运载工具，但其中也隐藏着一个精而小的程序，我们今天模拟一个电梯运行程序来开始我们面向对象之旅 DDD领域驱动开发入门，充血模型，面向对象程序设计核心思想原则...
学习设计模式（四）：状态机模式
qq_22754377的博客
08-27 2169
1.状态机模式介绍与设计思路 在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。 在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。 2.状态机模式代码实现 电梯状态接口 /** * @program: DesignPatterns * @description: 电梯状...
c++设计模式-行为型模式-状态模式
06-20
c++设计模式-行为型模式-状态模式；qt工程；c++简单源码； 状态（State）模式的定义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。
详解state状态模式及在C++设计模式编程中的使用实例
09-02
主要介绍了state状态模式及在C++设计模式编程中的使用实例,在设计模式中策略用来处理算法变化,而状态则是透明地处理状态变化,需要的朋友可以参考下
设计模式C++学习之状态模式（State）
09-07
设计模式C++学习之状态模式（State）
实例讲解C++设计模式编程中State状态模式的运用场景
09-02
主要介绍了实例讲解C++设计模式编程中State状态模式的运用场景,文章最后的适用性部分则介绍了一些State模式善于处理的情况,需要的朋友可以参考下
C++设计模式——状态模式（State）
qq_33766994的博客
03-30 203
状态模式 在软件构建过程中，某些对象的状态变化会导致行为也随之变化。允许一个对象在其内部状态改变时改变它的行为，使对象看起来似乎修改了其行为。 enum NetworkState{ Network_Open, Network_Close, Network_Connect, }; class NetworkProcessor{ NetworkState state; public: void Operation1(){ if (state == Netw
状态模式实例（电梯）
05-20
能让你迅速理解和运用设计模式中的状态模式，进行编程
C# 状态机实现
01-04
C# 状态机实现 ，参考基于特定领域实现，还有待完善，进一步研究
设计模式之状态模式实验报告
06-11
首先了解什么是状态模式，然后思考为何产生这种模式，意义何在。同时能够在实际的代码中体现这种模式，并且对比使用该模式与不使用的区别何在。
C++设计模式之状态模式(四)
ApeLife技术博客
08-31 1390
4、状态模式总结     状态模式将一个对象在不同状态下的不同行为封装在一个个状态类中，通过设置不同的状态对象可以让环境对象拥有不同的行为。而状态转换的细节对于客户端而言是透明的，客户端不直接操作状态类，也就不需要知道状态转换细节，降低了客户端与具体状态类的耦合性。状态类和环境类是一种组合的关系，当客户端调用环境类的方法时，环境类将委托调用状态类的方法。使用状态模式封装了一个个具体的状态类，
设计模式 ( 十七) 状态模式State（对象行为型）
管子（zero）的杂乱空间
05-11 1070
设计模式 ( 十七) 状态模式State（对象行为型） 1.概述 在软件开发过程中，应用程序可能会根据不同的情况作出不同的处理。最直接的解决方案是将这些所有可能发生的情况全都考虑到。然后使用if... ellse语句来做状态判断来进行不同情况的处理。但是对复杂状态的判断就显得“力不从心了”。随着增加新的状态或者修改一个状体（if else(或switch case)语句的增多或者修...
C++状态模式详解--设计模式（15）
程序猿老樊的博客
07-01 9602
State模式来源：        每个人、事物在不同的状态下会有不同表现（动作），而一个状态又会在不同的表现下转移到下一个不同的状态（State）。最简单的一个生活中的例子就是：地铁入口处，如果你放入正确的地铁票，门就会打开让你通过。在出口处也是验票，如果正确你就可以ok，否则就不让你通过（如果你动作野蛮，或许会有报警（Alarm））。      有限状态自动机（FSM）也是一个典型的状态不同，...
Elasticsearch初识与简单案例.pdf
04-29
Elasticsearch是一个基于Lucene的分布式全文搜索引擎，提供灵活且高效的搜索和分析功能。通过HTTP请求和客户端库，用户可以索引和搜索文档，执行复杂查询，进行数据分析，并享受高亮显示等特性。其高级功能如复合查询、聚合分析、滚动搜索等，使其适用于各种数据处理和分析场景。Elasticsearch还具有强大的监控和日志功能，确保集群稳定运行。总之，Elasticsearch是企业级搜索和分析的理想选择。
Python基于LSTM模型对全国的空气质量数据进行可视化分析预测源代码
最新发布
04-29
介绍 对全国2019年1月至2023年12月的空气质量数据进行分析，绘制时间序列图，展示每月/每季度的平均AQI变化趋势。绘制不同省份和城市的平均AQI热力图。分析不同污染物的浓度分布和趋势。绘制空气质量等级分布图。 需求说明 对空气质量数据进行数据分析，并使用LSTM模型进行预测。 安装教程 pip install jupyter pip install numpy pandas matplotlib seaborn 使用说明 在项目路径下打开终端输入jupyter notebook就行
百问网linux桌面GUI，基于LVGL 8.x。.zip
04-29
百问网linux桌面GUI，基于LVGL 8.x。
设计模式 状态模式 C++demo
03-26
以下是一个简单的状态模式示例，用于在C语言中实现状态转换： ...在这个例子中，我们有两种具体状态实现，它们打印不同的状态并且具有不同的转换行为。当我们更改状态时，我们可以看到输出切换为正确的状态输出。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值