3.8 State（状态） -- 对象行为型模式

在阐述状态模式之前，先来看一个例子。一个银行取款问题: 如果账户余额大于0，则正常取款；如果余额在-2000和0之间，则透支取款；如果余额小于-2000，则账户处于冻结状态，无法进行取款操作。

实现代码如下:

[cpp] view
plaincopy

//银行账户

class Account

{

private:

//余额

int m_nBalance;

public:

//取款操作

void WithDraw()

{

if( m_nBalance > 0 )

{

cout << "正常取款状态" << endl;

}

else if( m_nBalance > -2000 )

{

cout << "透支状态" << endl;

}

else

{

cout << "冻结状态" << endl;

}

}

};

执行取款这一操作，存在正常状态、透支状态、冻结状态三种状态。不同状态下，取款操作对应有不同的行为。如果需要添加一种新的状态，如:账户余额小于-10000，直接注销此账户，并且接受法院的传票，得修改上述代码。执行某一个操作，需要判断这一操作是在哪一个状态下执行的，判断该状态下是否具有该方法，以及特定状态下如何实现该方法，将导致大量的if...else条件判断，新增新的状态，得修改源代码，违背"开放封闭原则"。

因此有必要对这些状态进行封装，将状态的行为封装到具体的状态中。为了解决这些问题，我们可以使用状态模式，在状态模式中，我们将对象在每一个状态下的行为和状态转移语句封装在一个个状态类中，通过这些状态类来分散冗长的条件转移语句，让系统具有更好的灵活性和可扩展性。

1、状态模式概述

状态模式用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题。当系统中某个对象存在多个状态，这些状态之间可以进行转换，而且对象在不同状态下行为不相同时可以使用状态模式。状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象状态可以灵活变化，对于客户端而言，无须关心对象状态的转换以及对象所处的当前状态，无论对于何种状态的对象，客户端都可以一致处理。

状态模式(State Pattern)：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。其别名为状态对象(Objects for States)，状态模式是一种对象行为型模式。

在状态模式中引入了抽象状态类和具体状态类，它们是状态模式的核心。



状态模式结构图

在状态模式结构图中包含如下几个角色：

Context（环境类）：环境类又称为上下文类，它是拥有多种状态的对象。由于环境类的状态存在多样性且在不同状态下对象的行为有所不同，因此将状态独立出去形成单独的状态类。在环境类中维护一个抽象状态类State的实例，这个实例定义当前状态，在具体实现时，它是一个State子类的对象。

State（抽象状态类）：它用于定义一个接口以封装与环境类的一个特定状态相关的行为，在抽象状态类中声明了各种不同状态对应的方法，而在其子类中实现类这些方法，由于不同状态下对象的行为可能不同，因此在不同子类中方法的实现可能存在不同，相同的方法可以写在抽象状态类中。

ConcreteState（具体状态类）：它是抽象状态类的子类，每一个子类实现一个与环境类的一个状态相关的行为，每一个具体状态类对应环境的一个具体状态，不同的具体状态类其行为有所不同。

在状态模式中，我们将对象在不同状态下的行为封装到不同的状态类中，为了让系统具有更好的灵活性和可扩展性，同时对各状态下的共有行为进行封装，我们需要对状态进行抽象，引入了抽象状态类角色，其典型代码如下所示：

[cpp] view
plaincopy

class State

{

public:

//声明抽象业务方法，不同的具体状态类可以不同的实现

void handle();

};

在抽象状态类的子类即具体状态类中实现了在抽象状态类中声明的业务方法，不同的具体状态类可以提供完全不同的方法实现，在实际使用时，在一个状态类中可能包含多个业务方法，如果在具体状态类中某些业务方法的实现完全相同，可以将这些方法移至抽象状态类，实现代码的复用，典型的具体状态类代码如下所示

[cpp] view
plaincopy

class ConcreteState : public State

{

public:

void handle()

{

//方法具体实现代码

}

}

环境类维持一个对抽象状态类的引用，通过setState()方法可以向环境类注入不同的状态对象，再在环境类的业务方法中调用状态对象的方法，典型代码如下所示。

[cpp] view
plaincopy

class Context

{

private:

//维持一个对抽象状态对象的引用

State state;

//其他属性值，该属性值的变化可能会导致对象状态发生变化

int value;

public:

//设置状态对象

void setState(State state)

{

this.state = state;

}

//调用状态对象的业务方法

void request()

{

state.handle();

//其他代码

}

}

环境类实际上是真正拥有状态的对象，我们只是将环境类中与状态有关的代码提取出来封装到专门的状态类中，环境类Context与抽象状态类State之间是一种关联关系。和策略模式相似，策略模式封装的是一个个具体策略，环境类Context引用一个具体的策略；而状态模式封装的是一个个具体的状态，环境类Context也维持了一个对具体状态的引用。两者都是通过组合的方式，实现软件复用的功能。

2、智能空调的设计与实现

某软件公司将开发一套智能空调系统： 系统检测到温度处于20---30度之间，则切换到常温状态；温度处于30---45度，则切换到制冷状态； 温度小于20度，则切换到制热状态。请使用状态模式对此系统进行设计。

从需求中可以看出，空调可以处于三种状态: 制热状态、常温状态、制冷状态。每种状态下都存在三种行为:保持常温、制冷、制热。

空调抽象状态实现代码如下:

[cpp] view
plaincopy





//空调抽象状态类

class AirConditionerState

{

public:

//保持常温

virtual void KeepNormalTemperature(AirConditioner * pAirConditioner) = 0;

//制冷

virtual void refrigerate(AirConditioner * pAirConditioner) = 0;

//制热

virtual void Heat(AirConditioner * pAirConditioner) = 0;

};

三种具体状态类声明如下:

[cpp] view
plaincopy





//常温状态

class NormalTemperatureState : public AirConditionerState

{

public:

//保持常温

void KeepNormalTemperature(AirConditioner * pAirConditioner);

//制冷

void refrigerate(AirConditioner * pAirConditioner);

//制热

void Heat(AirConditioner * pAirConditioner);

};

//制冷状态

class RefrigerateState : public AirConditionerState

{

public:

//保持常温

void KeepNormalTemperature(AirConditioner * pAirConditioner);

//制冷

void refrigerate(AirConditioner * pAirConditioner);

//制热

void Heat(AirConditioner * pAirConditioner);

};

//制热状态

class HeatState : public AirConditionerState

{

public:

//保持常温

void KeepNormalTemperature(AirConditioner * pAirConditioner);

//制冷

void refrigerate(AirConditioner * pAirConditioner);

//制热

void Heat(AirConditioner * pAirConditioner);

};

每种状态下都存在保持常温、制冷、制热方法。这些方法带有一个AirConditioner类参数，方法内部使用这个参数回调空调的温度值，根据这个温度值，用于判断该方法如何实现，以及如何切换到其他状态。三种状态实现代码如下:

[cpp] view
plaincopy





/******************************正常温度状态******************************************/

//保持常温

void NormalTemperatureState::KeepNormalTemperature(AirConditioner * pAirConditioner)

{

int nTemperature = pAirConditioner->GetTemperature();

if( nTemperature > 20 && nTemperature <= 30 )

{

cout << "已经是常温状态，不能调节为常温" << endl;

}

}

//制冷

void NormalTemperatureState::refrigerate(AirConditioner * pAirConditioner)

{

int nTemperature = pAirConditioner->GetTemperature();

if( nTemperature > 30 && nTemperature <= 45 )

{

pAirConditioner->SetAirConditionerState(pAirConditioner->GetRefrigerateState());

cout << "切换到制冷状态" << endl;

}

}

//制热

void NormalTemperatureState::Heat(AirConditioner * pAirConditioner)

{

int nTemperature = pAirConditioner->GetTemperature();

if( nTemperature <= 20 )

{

pAirConditioner->SetAirConditionerState(pAirConditioner->GetHeatState());

cout << "切换到制热状态" << endl;

}

}

/******************************制冷状态******************************************/

//保持常温

void RefrigerateState::KeepNormalTemperature(AirConditioner * pAirConditioner)

{

int nTemperature = pAirConditioner->GetTemperature();

if( nTemperature > 20 && nTemperature <= 30 )

{

pAirConditioner->SetAirConditionerState(pAirConditioner->GetNormalTemperatureState());

cout << "切换到常温状态" << endl;

}

}

//制冷

void RefrigerateState::refrigerate(AirConditioner * pAirConditioner)

{

int nTemperature = pAirConditioner->GetTemperature();

if( nTemperature > 30 && nTemperature <= 45 )

{

cout << "已经是制冷状态，不能调节为制冷状态" << endl;

}

}

//制热

void RefrigerateState::Heat(AirConditioner * pAirConditioner)

{

int nTemperature = pAirConditioner->GetTemperature();

if( nTemperature <= 20 )

{

pAirConditioner->SetAirConditionerState(pAirConditioner->GetHeatState());

cout << "切换到制热状态" << endl;

}

}

/******************************制热状态******************************************/

//保持常温

void HeatState::KeepNormalTemperature(AirConditioner * pAirConditioner)

{

int nTemperature = pAirConditioner->GetTemperature();

if( nTemperature > 20 && nTemperature <= 30 )

{

pAirConditioner->SetAirConditionerState(pAirConditioner->GetNormalTemperatureState());

cout << "切换到常温状态" << endl;

}

}

//制冷

void HeatState::refrigerate(AirConditioner * pAirConditioner)

{

int nTemperature = pAirConditioner->GetTemperature();

if( nTemperature > 30 && nTemperature <= 45 )

{

pAirConditioner->SetAirConditionerState(pAirConditioner->GetRefrigerateState());

cout << "切换到制冷状态" << endl;

}

}

//制热

void HeatState::Heat(AirConditioner * pAirConditioner)

{

int nTemperature = pAirConditioner->GetTemperature();

if( nTemperature <= 20 )

{

cout << "已经是制热状态，不能调节为制热状态" << endl;

}

}

空调类，也就是环境类Contex,维护了一个状态的引用，实现的时候将调用状态对象的方法。声明代码如下:

[cpp] view
plaincopy





//空调类

class AirConditioner

{

private:

//空调名称

string m_strAirName;

//空调当前温度

int m_nTemperature;

//常温状态

AirConditionerState * m_pNormalTemperatureState;

//制冷状态

AirConditionerState * m_pRefrigerateState;

//制热状态

AirConditionerState * m_pHeatState;

//当前温度状态

AirConditionerState * m_pCurState;

public:

//构造函数

AirConditioner(string strAirName, int nTemperature);

//虚构函数

~AirConditioner();

//调节温度

void SetTemperature(int nTemperature);

//获取温度

int GetTemperature();

//设置空调状态

void SetAirConditionerState(AirConditionerState * pAirConditionerState);

//获取常温状态

AirConditionerState * GetNormalTemperatureState();

//获取制冷状态

AirConditionerState * GetRefrigerateState();

//获取制热状态

AirConditionerState * GetHeatState();

//保持常温

void KeepNormalTemperature();

//制冷

void refrigerate();

//制热

void Heat();

};

空调类实现代码如下：

[cpp] view
plaincopy





//构造函数

AirConditioner::AirConditioner(string strAirName, int nTemperature)

{

m_strAirName = strAirName;

m_nTemperature = nTemperature;

m_pNormalTemperatureState = new NormalTemperatureState();

m_pRefrigerateState = new RefrigerateState();

m_pHeatState = new HeatState();

m_pCurState = m_pNormalTemperatureState;

}

//虚构函数

AirConditioner::~AirConditioner()

{

delete m_pNormalTemperatureState;

m_pNormalTemperatureState = NULL;

delete m_pRefrigerateState;

m_pRefrigerateState = NULL;

delete m_pHeatState;

m_pHeatState = NULL;

}

//调节温度

void AirConditioner::SetTemperature(int nTemperature)

{

m_nTemperature = nTemperature;

}

//获取温度

int AirConditioner::GetTemperature()

{

return m_nTemperature;

}

//设置空调状态

void AirConditioner::SetAirConditionerState(AirConditionerState * pAirConditionerState)

{

m_pCurState = pAirConditionerState;

}

//获取常温状态

AirConditionerState * AirConditioner::GetNormalTemperatureState()

{

return m_pNormalTemperatureState;

}

//获取制冷状态

AirConditionerState * AirConditioner::GetRefrigerateState()

{

return m_pRefrigerateState;

}

//获取制热状态

AirConditionerState * AirConditioner::GetHeatState()

{

return m_pHeatState;

}

//保持常温

void AirConditioner::KeepNormalTemperature()

{

m_pCurState->KeepNormalTemperature(this);

}

//制冷

void AirConditioner::refrigerate()

{

m_pCurState->refrigerate(this);

}

//制热

void AirConditioner::Heat()

{

m_pCurState->Heat(this);

}

测试代码实现如下:

[cpp] view
plaincopy





#include <iostream>

#include "AirConditioner.h"

using namespace std;

int main()

{

AirConditioner * pAirConditioner = new AirConditioner("海尔空调", 25);

/****************常温状态*************************/

pAirConditioner->KeepNormalTemperature();

cout << endl;

/****************制冷状态*************************/

pAirConditioner->SetTemperature(33);

pAirConditioner->refrigerate();

cout << endl;

/****************制热状态*************************/

pAirConditioner->SetTemperature(15);

pAirConditioner->Heat();

/****************销毁操作*************************/

delete pAirConditioner;

pAirConditioner = NULL;

return 0;

}

编译并执行，结果如下:



将具体行为封装在常温状态、制冷状态、制热状态中。空调类(也就是环境类)维持一个当前状态的引用，当客户端调用环境类的方法时，将该调用操作委托给具体状态类。具体状态类实现该状态下的行为，以及控制切换到其他状态。客户端无需直接操作具体的状态类，而是由环境类代为处理，降低了客户端与具体状态类的耦合性。如果需要添加具体的状态类也很容易，只需要继承于抽象状态类并对环境类稍加修改就可以了。另外，也避免了大量if...else臃肿语句，把这些条件判断都封装成一个个状态类。

3、使用环境类实现状态的转换

在状态模式中实现状态转换时，具体状态类可通过调用环境类Context的setState()方法进行状态的转换操作，也可以统一由环境类Context来实现状态的转换。此时，增加新的具体状态类可能需要修改其他具体状态类或者环境类的源代码，否则系统无法转换到新增状态。但是对于客户端来说，无须关心状态类，可以为环境类设置默认的状态类，而将状态的转换工作交给具体状态类或环境类来完成，具体的转换细节对于客户端而言是透明的。

在上面的“智能空调状态转换”实例中，我们通过具体状态类来实现状态的转换。除此之外，我们还可以通过环境类来实现状态转换，环境类作为一个状态管理器，统一实现各种状态之间的转换操作。

下面通过简单实例来说明如何使用环境类实现状态转换：

某软件公司某开发人员欲开发一个屏幕放大镜工具，其具体功能描述如下：用户单击“放大镜”按钮之后屏幕将放大一倍，再点击一次“放大镜”按钮屏幕再放大一倍，第三次点击该按钮后屏幕将还原到默认大小。

State为抽象状态、NormalState为正常大小状态、LargerState为放大2倍大小状态、LargestState为放大4倍大小状态。Screen为屏幕类，也就是环境类Contex。

屏幕类声明如下:

[cpp] view
plaincopy

//屏幕类

class Screen

{

private:

//当前状态

State * m_pState;

//正常大小，2倍大小，4倍大小状态

State * m_pNormalState;

State * m_pLargerState;

State * m_pLargestState;

public:

Screen();

~Screen();

//屏幕点击事件

void OnClick();

//设置状态

void SetState(State * pState);

};

屏幕类实现代码如下：

[cpp] view
plaincopy

//构造函数

Screen::Screen()

{

//创建正常大小、2倍大小、4倍大小对象

m_pNormalState = new NormalState();

m_pLargerState = new LargerState();

m_pLargestState = new LargestState();

//初始状态为正常大小

m_pState = m_pNormalState;

m_pState->Display();

}

//虚构函数

Screen::~Screen()

{

if( NULL != m_pState )

{

delete m_pState;

m_pState = NULL;

}

}

//设置状态

void Screen::SetState(State * pState)

{

m_pState = pState;

}

//屏幕点击事件

void Screen::OnClick()

{

if( m_pState == m_pNormalState )

{

SetState(m_pLargerState);

m_pState->Display();

}

else if( m_pState == m_pLargerState )

{

SetState( m_pLargestState );

m_pState->Display();

}

else if( m_pState == m_pLargestState )

{

SetState(m_pNormalState);

m_pState->Display();

}

}

抽象状态类和具体状态类声明如下：

[cpp] view
plaincopy

//抽象状态

class State

{

public:

virtual void Display() = 0;

};

//正常大小状态

class NormalState : public State

{

public:

virtual void Display();

};

//两倍大小状态

class LargerState : public State

{

public:

virtual void Display();

};

//四倍大小状态

class LargestState : public State

{

public:

virtual void Display();

};

抽象状态类和具体状态类实现如下：

[cpp] view
plaincopy

void NormalState::Display()

{

printf("正常大小\n");

}

void LargerState::Display()

{

printf("2倍大小\n");

}

void LargestState::Display()

{

printf("4倍大小\n");

}

测试代码实现如下:

[cpp] view
plaincopy

#include <stdio.h>

#include "State.h"

int main()

{

Screen * pScreen = new Screen();

pScreen->OnClick();

pScreen->OnClick();

pScreen->OnClick();

delete pScreen;

pScreen = NULL;

return 0;

}

编译并执行，结果如下:



在上述代码中，所有的状态转换操作都由环境类Screen来实现，此时，环境类充当了状态管理器角色。如果需要增加新的状态，例如“八倍状态类”，需要修改环境类，这在一定程度上违背了“开闭原则”，但对其他状态类没有任何影响。这也是软件工程中的一种折中思想。

4、状态模式总结

状态模式将一个对象在不同状态下的不同行为封装在一个个状态类中，通过设置不同的状态对象可以让环境对象拥有不同的行为。而状态转换的细节对于客户端而言是透明的，客户端不直接操作状态类，也就不需要知道状态转换细节，降低了客户端与具体状态类的耦合性。状态类和环境类是一种组合的关系，当客户端调用环境类的方法时，环境类将委托调用状态类的方法。使用状态模式封装了一个个具体的状态类，可以避免出现if...else拥挤情况，使得代码易于维护，也更具扩展性。同时封装一个个状态类，也体现了"单一原则"。在实际开发中，状态模式具有较高的使用频率。

1. 主要优点

状态模式的主要优点如下：

(1) 封装了状态的转换规则，在状态模式中可以将状态的转换代码封装在环境类或者具体状态类中，可以对状态转换代码进行集中管理，而不是分散在一个个业务方法中，符合"单一原则"。

(2) 将所有与某个状态有关的行为放到一个类中，只需要注入一个不同的状态对象即可使环境对象拥有不同的行为。

(3) 允许状态转换逻辑与状态对象合成一体，而不是提供一个巨大的条件语句块，状态模式可以让我们避免使用庞大的条件语句来将业务方法和状态转换代码交织在一起。

(4) 可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

2. 主要缺点

状态模式的主要缺点如下：

(1) 状态模式的使用必然会增加系统中类和对象的个数，导致系统运行开销增大。

(2) 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱，增加系统设计的难度。

(3) 状态模式对“开闭原则”的支持并不太好，增加新的状态类需要修改那些负责状态转换的源代码，否则无法转换到新增状态；而且修改某个状态类的行为也需修改对应类的源代码。

3.适用场景

在以下情况下可以考虑使用状态模式：

(1) 对象的行为依赖于它的状态（如某些属性值），状态的改变将导致行为的变化。

(2) 在代码中包含大量与对象状态有关的条件语句，这些条件语句的出现，会导致代码的可维护性和灵活性变差，不能方便地增加和删除状态，并且导致客户类与类库之间的耦合增强。

4.状态模式具体应用



(1)电梯升降系统的设计: 存在打开、关闭、运行、停止状态。各个状态下将有不同的行为。例如:在运行状态下可以进行停止操作，但无法进行打开和关闭操作。



(2)投票系统的设计: 投票1次则为正常投票状态、投票次数在2---5次之间则为重复投票状态、投票次数在5---8次之间则为恶意投票状态、投票次数大于8次则拉入黑名单状态。



(3)酒店订房系统的设计:存在订房状态、入住状态、取消订状态、退房状态。各状态下对应有不同的行为。



(4)超市、酒店、Ktv存在不同等级的用户，各等级用户处于不同状态，对应有不同权限的行为； 在游戏中也同样存在各种不同角色状态，各状态对应有不同的行为。



(5)银行取款系统的设计:存在正常状态、透支状态、冻结状态。不同状态下将有不同行为。例如:冻结状态不能进行取款，而正常状态和透支状态可以进行取款操作。

(6)操作系统的任务调度状态图: 存在等待状态、就绪状态、运行状态、停止状态。

(7)TCP网络连接过程中，存在三次握手状态。发送连接请求、应答请求、建立连接、断开连接等状态。



(8)数据库中的事务处理机制。存在OldClean状态、OldDirty状态、OldDelete状态、Deleted状态。

(9)在工控领域，通信领域存在大量的状态图，某些芯片也存在时序图，高低电平的变化，系统时钟信号的变化，存在大量状态的变化。

(10)生活中的状态模式: 从儿童到中年，再到老年，是人生状态的变化；从35度骤降到15度是气候的变化；白手起家到腰缠万贯是事业的变化。