意图:允许一个对象在其内部状态改变时改变它的行为.对象看起来似乎修改了它的类.
适用性:
1 一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为.
2 一个操作中含有庞大的多分支的条件语句,且这些分支依赖于该对象的状态.这个状态通常用一个或多个枚举常量表示,通常,有多个操作包含这一相同的条件结构.State模式将每一个条件分支放入一个独立的类中.这样可以根据对象自身情况将对象的状态作为一个对象,对象可以不依赖于其他对象而独立变化.
结构:
参与者:
Context(环境):
1定义客户感兴趣的接口. 2维护一个ConcreteState子类的实例,这个实例定义当前状态。
State(状态):定义一个接口以封装与Context的一个特定状态相关的行为。
ConcreteStateSubclasses(具体状态子类):
每一子类实现一个与Context的一个状态相关的行为。
协作:
Context将于状态相关的请求委托给当前的ConcreteState对象处理。
Context可将自身作为一个参数传递给处理该请求的状态对象。这使得状态对象在必要时可访问Context
Context是客户使用的主要接口。客户可用状态对象来配置一个Context,一旦一个Context配置完毕,它的客户不再需要直接与状态对象打交道。
Context或ConcreteState子类都可决定哪个状态时另外哪一个的后继者,以及是在何种条件下进行状态转换。
效果:
1 它将于特定状态相关的行为局部化,并且将不同状态的行为分割开来。决定状态转移的逻辑不是在单块的if或switch语句中,而是分布在State子类之间。将每个状态转换和动作封装到一个类中,就把着眼点从执行状态提高到整个对象的状态。使代码结构话并使其意图更清晰。
2 使状态转换显示化:State保证Context不会发生内部状态不一致的情况,因为从Context的角度来看,状态转换是原子的。
3 State对象可被共享
实现:
1 谁定义状态转换:两者都可以,但若让State子类自身指定它们的后继状态以及何时进行转换,更灵活更合适。但是缺点是一个State子类至少拥有一个其他子类的信息,这就在各子类之间产生了实现依赖。
2 基于表的另一种方法 :查找表的方式,使用表江输入映射到状态转换。对每一个状态,一张表将每一个可能的输入映射到一个后继状态。
表驱动的状态及与State模式的主要区别:State模式对于状态相关的行为进行建模,而表驱动的方式着重于定义状态转换。
3 创建和销毁State对象:何时创建何时销毁
4 使用动态继承
相关模式:
Flyweight:解释了何时以及怎样共享状态对象
状态对象通常是Singleton
书中代码:
//状态模式
#include <iostream>
using namespace std;
//复制了TCPConnection的状态改变接口,每一个TCPState操作
//都以一个TCPConnection实例作为一个参数,从而让TCPState可以访问其中的数据和改变状态的链接
//以下类之间有相互依赖关系,所以需要注意前后顺序
class TCPConnection;
class TCPState
{
public:
virtual ~TCPState()
{
}
virtual void ActiveOpen(TCPConnection* t)
{
}
virtual void PassiveOpen(TCPConnection* t)
{
}
virtual void Close(TCPConnection* t)
{
}
virtual void Synchronize(TCPConnection* t)
{
}
virtual void Acknowlegde(TCPConnection* t)
{
}
virtual void Send(TCPConnection* t)
{
}
protected:
void ChangeState(TCPConnection* t, TCPState* s);
};
//类中所有的操作在完成与状态相关的工作后,这些操作都调用
//ChangeState操作来改变TCPConnection的状态。
//TCPState的子类.都是单例模式
class TCPEstablished : public TCPState
{
public:
//static成员函数不能声明为虚函数,也不能声明为const
static TCPState* Instance()
{
if (_instance == 0)
_instance = new TCPEstablished;
else
return _instance;
}
void Close(TCPConnection* t);
private:
TCPEstablished()
{
}
static TCPState* _instance;
};
TCPState* TCPEstablished::_instance = 0;
//TCPState的子类.都是单例模式
class TCPListen : public TCPState
{
public:
//static成员函数不能声明为虚函数,也不能声明为const
static TCPState* Instance()
{
if (_instance == 0)
_instance = new TCPListen;
else
return _instance;
}
void Send(TCPConnection* t)
{
cout << "Send" << endl;
ChangeState(t, TCPEstablished::Instance());
}
private:
TCPListen()
{
}
static TCPState* _instance;
};
TCPState* TCPListen::_instance = 0;
void TCPEstablished::Close(TCPConnection* t)
{
cout << "进行Close" << endl;
ChangeState(t, TCPListen::Instance());
}
//TCPState的子类.都是单例模式
class TCPClosed : public TCPState
{
public:
//static成员函数不能声明为虚函数,也不能声明为const
static TCPState* Instance()
{
if (_instance == 0)
_instance = new TCPClosed;
else
return _instance;
}
void ActiveOpen(TCPConnection* t)
{
cout << "进行ActiveOpen" << endl;
ChangeState(t, TCPEstablished::Instance());
}
void PassiveOpen(TCPConnection* t)
{
cout << "进行PassiveOpen" << endl;
ChangeState(t, TCPListen::Instance());
}
private:
TCPClosed()
{
}
static TCPState* _instance;
};
TCPState* TCPClosed::_instance = 0;
//提供了一个传送数据的接口并处理改变状态的请求
class TCPConnection
{
public:
//将State初始化为close()状态
TCPConnection()
{
_state = TCPClosed::Instance();
}
void ActiveOpen()
{
_state->ActiveOpen(this);
}
void PassiveOpen()
{
_state->PassiveOpen(this);
}
void Close()
{
_state->Close(this);
}
void Synchronize()
{
_state->Synchronize(this);
}
void Acknowlegde()
{
_state->Acknowlegde(this);
}
void Send()
{
_state->Send(this);
}
protected:
friend class TCPState; //这样State类可以访问ChangeState,
//从而可以改变TCPConnection的状态
void ChangeState(TCPState* s)
{
_state = s;
}
private:
TCPState* _state;
};
void TCPState::ChangeState(TCPConnection* t, TCPState* s)
{
t->ChangeState(s);
}