设计模式 之 STATE（状态）实例 —对象行为型模式

最新推荐文章于 2019-04-29 17:59:20 发布
最新推荐文章于 2019-04-29 17:59:20 发布
阅读量554 收藏
点赞数
文章标签： 设计模式

本文是对于 《设计模式 可复用面向对象软件的基础 Erich Gamma、Richard Helm》一书中的状态模型例子进行实现，并做了一些说明


引目：

          考虑一个表示网络连接的类T C P C o n n e c t i o n。一个T C P C o n n e c t i o n对象的状态处于若干不同状态之一: 连接已建立（ E s t a b l i s h e d）、正在监听( L i s t e n i n g )、连接已关闭( C l o s e d )。当一个T C P C o n n e c t i o n对象收到其他对象的请求时, 它根据自身的当前状态作出不同的反应。例如，一个O p e n请求的结果依赖于该连接是处于连接已关闭状态还是连接已建立状态。S t a t e模式描述了T C P C o n n e c t i o n如何在每一种状态下表现出不同的行为。这一模式的关键思想是引入了一个称为T C P S t a t e的抽象类来表示网络的连接状态。T C P S t a t e类为各表示不同的操作状态的子类声明了一个公共接口。T C P S t a t e的子类实现与特定状态相关的行为。例如, TCPEstablished和T C P C l o s e d类分别实现了特定于T C P C o n n e c t i o n的连接已建立状态和连接已关闭状态的行为。


T C P C o n n e c t i o n类维护一个表示T C P连接当前状态的状态对象(一个T C P S t a t e子类的实例)。T C P C o n n e c t i o n类将所有与状态相关的请求委托给这个状态对象。T C P C o n n e c t i o n使用它的T C P S t a t e子类实例来执行特定于连接状态的操作。一旦连接状态改变， T C P C o n n e c t i o n对象就会改变它所使用的状态对象。例如当连接从已建立状态转为已关闭状态时, TCPConnection 会用一个T C P C l o s e d的实例来代替原来的T C P E s t a b l i s h e d的实例。

状态模型的设计结构如下：


示例的实现

1 ) 谁定义状态转换S t a t e模式不指定哪一个参与者定义状态转换准则。如果该准则是固定的, 那么它们可在C o n t e x t中完全实现。然而若让S t a t e子类自身指定它们的后继状态以及何时进行转换, 通常更灵活更合适。这需要C o n t e x t增加一个接口, 让S t a t e对象显式地设定C o n t e x t的当前状态。

2) 基于表的另一种方法在C++ Programming Style[Car92]中, Carg i l描述了另一种将结构加载在状态驱动的代码上的方法: 他使用表将输入映射到状态转换。对每一个状态, 一张表将每一个可能的输入映射到一个后继状态。实际上, 这种方法将条件代码(和S t a t e模式下的虚函数)映射为一个查找表。

3 ) 创建和销毁S t a t e对象一个常见的值得考虑的实现上的权衡是, 究竟是( 1 )仅当需要S t a t e对象时才创建它们并随后销毁它们，还是( 2 )提前创建它们并且始终不销毁它们。

4 ) 使用动态继承改变一个响应特定请求的行为可以用在运行时刻改变这个对象的类的
办法实现, 但这在大多数面向对象程序设计语言中都是不可能的。

代码示例

代码是自己照着题意写的，可能有的 地方不怎么规范，但基本思想已明确，下是完整的代码，仅供参考与学习

[cpp] view plain copy print ?
  1. #include <iostream> 
  2. enum { 
  3.     S_CLOSE, 
  4.     S_ESTABLISH, 
  5.     S_LISTE  
  6. }; 
  7. class TCPConnection; 
  8. class TCPEstablished; 
  9. class TCPClosed ; 
  10.  
  11. class TCPState{ 
  12. public: 
  13.     virtual int ActiveOpen(TCPConnection *tcp){std::cout <<"some thing must be wrong"<<std::endl;return 0;} 
  14.     virtual int PassiveOpen(TCPConnection *tcp){std::cout <<"some thing must be wrong"<<std::endl;return 0;} 
  15.     virtual int Connect(TCPConnection *tcp){std::cout <<"some thing must be wrong"<<std::endl;return 0;} 
  16.     virtual int Close(TCPConnection * tcp){std::cout <<"some thing must be wrong"<<std::endl;return 0;} 
  17.     virtual int Acknoledge(TCPConnection * tcp){std::cout <<"this type is :"<<_curStatu<<"    0:S_CLOSE,1:S_ESTABLISH,2:S_LISTE "<<std::endl;  return 0;} 
  18.     virtual int ChageState(TCPConnection * tcp,TCPState * s); 
  19. public: 
  20.     virtual ~TCPState(){}; 
  21. protected: 
  22.     int _curStatu ; 
  23.  
  24. }; 
  25.  
  26. class TCPEstablished:public TCPState{ 
  27. public: 
  28.     int Close(TCPConnection * tcp); 
  29.     static TCPState* Instance() ; 
  30. }; 
  31. class TCPListen:public TCPState{ 
  32. public: 
  33.     virtual int Connect(TCPConnection *tcp); 
  34.     virtual int Close(TCPConnection * tcp); 
  35.     static TCPState* Instance() ; 
  36. }; 
  37. class TCPClosed:public TCPState{ 
  38. public: 
  39.     int PassiveOpen(TCPConnection *tcp); 
  40.     virtual int ActiveOpen(TCPConnection *tcp); 
  41.     static TCPState* Instance(); 
  42. }; 
  43.  
  44. class TCPConnection{ 
  45. private: 
  46.     TCPState * state ; 
  47. public: 
  48.     int Init(); 
  49.     int ActiveOpen(); 
  50.     int PassiveOpen(); 
  51.     int Connect(); 
  52.     int Close() ; 
  53.     int Acknoledge(); 
  54.     int ChageState(TCPState * s); 
  55.  
  56. }; 
  57. /defines of method for TCPState / 
  58. int TCPState::ChageState(TCPConnection * tcp,TCPState * s){ 
  59.     tcp->ChageState(s); 
  60.     return 0; 
  61. } 
  62.  
  63.  
  64. defines of method for classes inherited TCPState/ 
  65.  
  66. int TCPEstablished::Close(TCPConnection * tcp){ 
  67.     std::cout << "change status :Established ---> Close"<<std::endl; 
  68.  
  69.     tcp->ChageState(TCPClosed::Instance()); 
  70.     return 0; 
  71. } 
  72.  
  73. TCPState* TCPEstablished::Instance(){ 
  74.     return new TCPEstablished ; 
  75. } 
  76.  
  77. int TCPListen::Connect(TCPConnection *tcp){ 
  78.     std::cout << "change status :Listen ---> Established"<<std::endl; 
  79.  
  80.     tcp->ChageState(TCPEstablished::Instance()); 
  81.     return 0; 
  82. } 
  83.  
  84. int TCPListen::Close(TCPConnection * tcp){ 
  85.     std::cout << "change status :Listen ---> Close"<<std::endl; 
  86.     tcp->ChageState(TCPClosed::Instance()); 
  87.     return 0; 
  88. } 
  89. TCPState * TCPListen::Instance(){ 
  90.     return new TCPListen ; 
  91. } 
  92.  
  93. int TCPClosed::ActiveOpen(TCPConnection *tcp){ 
  94.     std::cout << "change status :Close ---> Established"<<std::endl; 
  95.     tcp->ChageState(TCPEstablished::Instance()); 
  96.     return 0; 
  97. } 
  98. int TCPClosed::PassiveOpen(TCPConnection *tcp){ 
  99.     std::cout << "change status :Close ---> Lisen"<<std::endl; 
  100.     tcp->ChageState(TCPListen::Instance()); 
  101.     return 0; 
  102. } 
  103. TCPState * TCPClosed::Instance(){ 
  104.     return new TCPClosed ; 
  105. } 
  106. //TCPConnection/// 
  107. int TCPConnection::Init(){ 
  108.     state = TCPClosed::Instance(); 
  109.     return 0; 
  110. } 
  111. int TCPConnection::ActiveOpen(){ 
  112.     state->ActiveOpen(this); 
  113.     return 0; 
  114. } 
  115. int TCPConnection::PassiveOpen(){ 
  116.     state->PassiveOpen(this) ; 
  117.     return 0; 
  118. } 
  119. int TCPConnection::ChageState(TCPState * s){ 
  120.     if(!state) 
  121.         delete state ; 
  122.     state = s ; 
  123.     return 0; 
  124. } 
  125. int TCPConnection::Connect(){ 
  126.     state->Connect(this) ; 
  127.     return 0; 
  128. } 
  129. int TCPConnection::Close() { 
  130.     state->Close(this); 
  131.     return 0; 
  132. } 
  133. int main(int arg,char ** argc){ 
  134.     TCPConnection t ; 
  135.     t.Init(); 
  136.     t.ActiveOpen(); 
  137.     t.Close(); 
  138.     t.PassiveOpen(); 
  139.     t.ActiveOpen(); 
  140.     t.Close();   
  141. }  
#include <iostream>
enum {
	S_CLOSE,
	S_ESTABLISH,
	S_LISTE 
};
class TCPConnection;
class TCPEstablished;
class TCPClosed ;

class TCPState{
public:
	virtual int ActiveOpen(TCPConnection *tcp){std::cout <<"some thing must be wrong"<<std::endl;return 0;}
	virtual int PassiveOpen(TCPConnection *tcp){std::cout <<"some thing must be wrong"<<std::endl;return 0;}
	virtual int Connect(TCPConnection *tcp){std::cout <<"some thing must be wrong"<<std::endl;return 0;}
	virtual int Close(TCPConnection * tcp){std::cout <<"some thing must be wrong"<<std::endl;return 0;}
	virtual int Acknoledge(TCPConnection * tcp){std::cout <<"this type is :"<<_curStatu<<"	0:S_CLOSE,1:S_ESTABLISH,2:S_LISTE "<<std::endl;  return 0;}
	virtual int ChageState(TCPConnection * tcp,TCPState * s);
public:
	virtual ~TCPState(){};
protected:
	int _curStatu ;

};

class TCPEstablished:public TCPState{
public:
	int Close(TCPConnection * tcp);
	static TCPState* Instance() ;
};
class TCPListen:public TCPState{
public:
	virtual int Connect(TCPConnection *tcp);
	virtual int Close(TCPConnection * tcp);
	static TCPState* Instance() ;
};
class TCPClosed:public TCPState{
public:
	int PassiveOpen(TCPConnection *tcp);
	virtual int ActiveOpen(TCPConnection *tcp);
	static TCPState* Instance();
};

class TCPConnection{
private:
	TCPState * state ;
public:
	int Init();
 	int ActiveOpen();
 	int PassiveOpen();
	int Connect();
	int Close() ;
	int Acknoledge();
	int ChageState(TCPState * s);

};
/defines of method for TCPState /
int TCPState::ChageState(TCPConnection * tcp,TCPState * s){
	tcp->ChageState(s);
	return 0;
}


defines of method for classes inherited TCPState/

int TCPEstablished::Close(TCPConnection * tcp){
	std::cout << "change status :Established ---> Close"<<std::endl;

	tcp->ChageState(TCPClosed::Instance());
	return 0;
}

TCPState* TCPEstablished::Instance(){
	return new TCPEstablished ;
}

int TCPListen::Connect(TCPConnection *tcp){
	std::cout << "change status :Listen ---> Established"<<std::endl;

	tcp->ChageState(TCPEstablished::Instance());
	return 0;
}

int TCPListen::Close(TCPConnection * tcp){
	std::cout << "change status :Listen ---> Close"<<std::endl;
	tcp->ChageState(TCPClosed::Instance());
	return 0;
}
TCPState * TCPListen::Instance(){
	return new TCPListen ;
}

int TCPClosed::ActiveOpen(TCPConnection *tcp){
	std::cout << "change status :Close ---> Established"<<std::endl;
	tcp->ChageState(TCPEstablished::Instance());
	return 0;
}
int TCPClosed::PassiveOpen(TCPConnection *tcp){
	std::cout << "change status :Close ---> Lisen"<<std::endl;
	tcp->ChageState(TCPListen::Instance());
	return 0;
}
TCPState * TCPClosed::Instance(){
	return new TCPClosed ;
}
//TCPConnection///
int TCPConnection::Init(){
	state = TCPClosed::Instance();
	return 0;
}
int TCPConnection::ActiveOpen(){
	state->ActiveOpen(this);
	return 0;
}
int TCPConnection::PassiveOpen(){
	state->PassiveOpen(this) ;
	return 0;
}
int TCPConnection::ChageState(TCPState * s){
	if(!state)
		delete state ;
	state = s ;
	return 0;
}
int TCPConnection::Connect(){
	state->Connect(this) ;
	return 0;
}
int TCPConnection::Close() {
	state->Close(this);
	return 0;
}
int main(int arg,char ** argc){
	TCPConnection t ;
	t.Init();
	t.ActiveOpen();
	t.Close();
	t.PassiveOpen();
	t.ActiveOpen();
	t.Close();	
}

小结

 

转自 http://blog.csdn.net/rao_warrior/article/details/8266607

全国十大靠谱儿青年
关注
java 设计模式之State(状态模式）
08-29
Java 设计模式之 State（状态模式）是行为型模式之一，主要解决的问题是当一个对象的行为取决于它的状态，并且它需要在运行时刻根据不同的状态对其行为进行改变时，如何对其进行设计和实现。 State 模式的定义 ...
【设计模式】状态模式
weixin_34005042的博客
06-20 281
状态模式 在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。 在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。 介绍 意图：允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。 主要解决：对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为...
状态模式(state)解析例子
weixin_33770878的博客
10-06 512
摘要：本文深入浅出的讲述了设计模式中的状态模式,并给出了简单的示例,例子浅显易懂,并附带源代码。 状态模式属于对象创建型模式，其意图是允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了他的类。比较常见的例子是在一个表示网络连接的类TCPConnection，一个TCPConnection对象的状态处于若干不同的状态之一:连接已经建立(Establ...
23种设计模式 之 State模式（状态模式）[C语言实现]
编程语言小筑
11-14 1157
一、概念定义 State模式：允许一个对象在其状态发生改变时，改变它的行为。 State模式和Strategy模式非常相似，需要说明的是两者的思想是一致的；只不过封装的对象不同：State模式封装的是不同的状态，而Strategy模式封装的是不同的算法。 State模式主要解决的问题是：在开发过程中，时常遇到需要根据不同的状态需要进行不同的处理操作的问题。大部分人采用的是switch-...
Java设计模式之State模式：例子
小宝
07-19 171
研究State模式的人很多，网上有很多有价值的文章，尤其是那个遍历矩形的例子，相当好。看了很多，还是没太理解透彻，只好照葫芦画瓢了。 水的三种状态，冰（Ice） 液态水（LiquidWater）蒸汽（Steam） 加热（heatUp） 冷却（Cold）的时候改变状态。 package action.state2; public interface Water { public void...
Java设计模式之状态模式（State模式）介绍
09-03
2. **State（状态）**：这是个抽象接口，定义了所有可能的状态行为。在示例中，没有明确的`State`接口，但我们可以想象一个`ColorState`接口，包含`operate()`方法。 3. **ConcreteState（具体状态）**：实现了`...
实例讲解C++设计模式编程中State状态模式的运用场景
09-02
State模式是一种行为设计模式，它使对象能够在内部状态改变时改变其行为，对象看起来似乎修改了它的类。在C++编程中，State模式通常用于管理对象的状态转换，从而避免复杂的条件分支语句，并提高代码的可读性和可...
设计模式之状态模式实例
09-07
状态模式是一种行为设计模式，它允许对象在内部状态改变时改变其行为，对象看起来似乎修改了它的类。这种模式常用于处理对象的状态变化，使得代码更易于理解和维护。在这个实例中，我们将通过Java来深入理解并应用...
详解state状态模式及在C++设计模式编程中的使用实例
09-02
主要介绍了state状态模式及在C++设计模式编程中的使用实例,在设计模式中策略用来处理算法变化,而状态则是透明地处理状态变化,需要的朋友可以参考下
设计模式之State模式
robin912的专栏
07-12 275
设计模式之State模式 设计模式State主要用户状态变化处理，如果不用State模式，需要使用多次if语句判断状态值，然后执行不同的操作．在State模式下，每个模式为一个类，在类中给出当前模式下的对应操作,　让相关的操作统一在一个类中独立实现． State模式的角色组成: Context: 提供底层接口，上下文环境(state变量), 上层抽象的业务逻辑等 State: Stat...
行为型模式之 状态模式
weixin_30344795的博客
03-05 71
状态模式(State Pattern) ：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。其别名为状态对象(Objects for States)，状态模式是一种对象行为型模式。 主要解决：对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。 何时使用：代码中包含大量与对象状态有关的条件语句。 如何解决：将各种具体的状态类抽象出来。 关键代...
State模式
hackerHL的博客
03-07 343
实际开发工作中，首要是把功能完成，再考虑怎么样进行重构，使用什么样的设计模式。一个类的动作是根据这个类的内部状态的不同而有不同的动作。
行为型模式之状态模式
qq_30357519的博客
04-29 266
行为型模式之状态模式场景解决方案应用状态模式来解决的思路模式结构和说明示例代码模式讲解1. 状态和行为2. 行为的平行性模式的缺点 状态模式(State Pattern),当一个对象的现下状态改变时,允许改变其行为,这个对象看起来像是改变了其类 状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况,把状态的判断逻辑转移到表示不同状态的一系列类当中,可以把复杂的判断逻辑简化 场...
图解设计模式 - State 模式
wujunyucg的博客
12-26 372
读书笔记 仅供参考简述State 模式就是用类表示状态，从例子来看比较清晰角色和 UMLState表示状态，定义根据不同状态进行不同处理的接口（API）。ConcreteState各个具体的状态。Context角色持有表示当前状态的 ConcreteState 角色。定义了供外部调用者使用 State 模式的接口（API） 。UML例子例程是一个使用金库的 GUI 程序，有使用金库，按下警铃和拨通电
图解设计模式-State模式
localhost
04-22 426
State(状态):定义了根据不同状态进行不同处理的接口 ConcreteState（具体的状态）：表示各个具体的状态，实现了State接口 Context(状况，上下文):该角色持有表示当前状态的ConcreteState角色对象，还对外提供了接口 ...
设计模式学习笔记——状态(State)模式框架
Switch的博客
04-13 4429
设计模式学习笔记——状态(State)模式框架@(设计模式)[设计模式, 状态模式, State]设计模式学习笔记状态State模式框架 基本介绍 状态案例 类图 实现代码 State接口 DayState类 NightState类 Context接口 SafeFrame类 测试类 运行结果 界面 控制台 状态模式中的角色 State状态 ConcreteState具体状态 Context状况前后关
操作型模式之State（状态）模式
lin
04-08 416
1.如果你期望各个类都实现一个操作，每个类代表一个不同的状态，可使用State（状态）模式 2.举例//状态抽象类 public abstract class State { abstract void handle(); }//状态A类 public class StateA extends State{ @Override void handle() {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值