设计模式总结

状态模式

在实际开发中，我们经常会遇到这种情况；一个对象有多种状态，在每一个状态下，都会有不同的行为。那么在代码中我们经常是这样实现的。

代码如下:

typedef enum tagState
{
     state0,
     state1,
     state2
}State;
 
void Action(State actionState)
{
     if (actionState == state0)
     {
          // DoSomething
     }
     else if (actionState == state1)
     {
          // DoSomething
     }
     else if (actionState == state2)
     {
          // DoSomething
     }
     else
     {
          // DoSomething
     }
}

 

而这种就好比简单工厂模式，当我们增加新的状态类型时，我们又需要修改原来的代码，这种对于测试是很不利的；由于简单工厂的缺点那么的明显，后来的工厂模式就克服了这个缺点，我们就可以借鉴工程模式，来解决这种随着状态增加而出现的多分支结构，而这就是我今天要总结的状态模式。

 

状态模式

 

状态模式的重点在于状态转换，很多时候，对于一个对象的状态，我们都是让这个对象包含一个状态的属性，这个状态属性记录着对象的具体状态，根据状态的不同使用分支结构来执行不同的功能

State类，抽象状态类，定义一个接口以封装与Context的一个特定状态相关的行为。
ConcreteState类，具体状态，每一个子类实现一个与Context的一个状态相关的行为。
Context类，维护一个ConcreteState子类的实例，这个实例定义当前的状态。

C++代码实现：

#include <iostream>  
using namespace std;

#define SAFE_DELETE(p) if (p) { delete p; p = NULL; }

/*声明Context类*/
class Context;
 

class State
{
public:
     virtual void Handle(Context *pContext) = 0;
};


class Context
{
public:
     Context(State *pState) : m_pState(pState){}
 
     void Request()
     {
          if (m_pState)
          {
               m_pState->Handle(this);
          }
     }
 
     void ChangeState(State *pState)
     {
          m_pState = pState;
     }
 
private:
     State *m_pState; //这里的State指针是实现特定状态相关的关键
};


class ConcreteStateA : public State
{
public:
     virtual void Handle(Context *pContext)
     {
          cout<<"I am concretestateA."<<endl;
     }
};
 

class ConcreteStateB : public State
{
public:
     virtual void Handle(Context *pContext)
     {
          cout<<"I am concretestateB."<<endl;
     }
};
 

int main()
{
     State *pStateA = new ConcreteStateA();
     State *pStateB = new ConcreteStateB();
     Context *pContext = new Context(pStateA); //将具体状态类对象交由Context类管理
     
     pContext->Request();//Context类根据对象状态，调用该对象的特定函数Request
     pContext->ChangeState(pStateB); //改变对象状态
     pContext->Request();

     SAFE_DELETE(pContext);
     SAFE_DELETE(pStateB);
     SAFE_DELETE(pStateA);
     
     return 0;
}

这里例子的实现思路：
一个抽象状态类State：只包含纯虚函数Handle，然后定义两个具体状态类，这两个状态类重写了Handle函数；然后是最关键的Context类，这个类是包含了一个State指针，指针指向不同的对象（自己去改变这个指针使之指向新的对象），会导致Context去调用不同的对象方法，这也是虚函数机制的一大特点； 

使用场合

在以下两种情况下均可使用State模式：

1.一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为；
2.一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举常量表示。通常有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这使得你可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其它对象而独立变化。

---

中介者模式

中介者模式：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式的例子很多，大到联合国安理会，小到房屋中介，都扮演了中间者的角色，协调各方利益。

       本文就以租房为例子，如果没有房屋中介，那么房客要自己找房东，而房东也要自己找房客，非常不方便。有了房屋中介机构就方便了，房东可以把要出租的房屋信息放到中介机构，而房客可以去中介机构咨询。在软件中，就是多个对象之间需要通信，如果没有中介，对象就需要知道其他对象，最坏情况下，可能需要知道所有其他对象，而有了中介对象就方便多了，对象只需与中介对象通信，而不用知道其他的对象。这就是中介者模式，下面以租房为例，给出中介者模式的UML图。

                                         

租客发消息给中介，并从中介那里得到房东需要出租的信息，房东也发消息给中介自己想要出租房子的信息，中介将此消息给租客。

        C++的实现：
 

class Mediator;
//人基类
class Person
{
protected:
	Mediator *m_mediator; //中介
public:
	virtual void SetMediator(Mediator *mediator) {} //设置中介
	virtual void SendMessage(string message) {}    //向中介发送信息
	virtual void GetMessage(string message) {}     //从中介获取信息
};

//中介基类
class Mediator
{
public:
	virtual void Send(string message, Person *person) {}
	virtual void SetA(Person *A) {}  //设置其中一方
	virtual void SetB(Person *B) {}
};

//租房者
class Renter : public Person
{
public:
	void SetMediator(Mediator *mediator) { m_mediator = mediator; }
	void SendMessage(string message) { m_mediator->Send(message, this); }
	void GetMessage(string message) { cout << "租房者收到的信息" << endl << message; }
};

//房东
class Landlord : public Person
{
public:
	void SetMediator(Mediator *mediator) { m_mediator = mediator; }
	void SendMessage(string message) { m_mediator->Send(message, this); }
	void GetMessage(string message) { cout << "房东收到的信息：" << endl << message; }
};

//房屋中介
class HouseMediator : public Mediator
{
private:
	Person *m_A; //租房者
	Person *m_B; //房东
public:
	HouseMediator() : m_A(0), m_B(0) {}
	void SetA(Person *A) { m_A = A; }
	void SetB(Person *B) { m_B = B; }
	void Send(string message, Person *person)
	{
		if (person == m_A) //租房者给房东发信息
			m_B->GetMessage(message); //房东收到信息
		else
			m_A->GetMessage(message);
	}
};

int main()
{
	Mediator *mediator = new HouseMediator();
	Person *person1 = new Renter();    //租房者
	Person *person2 = new Landlord();  //房东

	mediator->SetA(person1);
	mediator->SetB(person2);

	person1->SetMediator(mediator);
	person2->SetMediator(mediator);

	person1->SendMessage("我想租套房子，价格800元一个月\n");
	cout << endl;
	person2->SendMessage("出租房子：南京路100号，70平米，1000元一个月\n");
	delete person1; delete person2; delete mediator;
	system("pause");
	return 0;
}

 

中介者模式很容易在系统中应用，也很容易在系统中误用。当系统出现了多对多交互复杂的对象群时，不要急于使用中介者模式，而要先反思你的系统在设计上是不是合理。   

     优点：Mediator的出现减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator；  由于把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到它们之间的交互上来，也就是站在一个更宏观的角度去看待系统。

     缺点：由于ConcreteMediator控制了集中化。于是就把交互的复杂性变为了中介者的复杂性，使得中介者比任何一个ConcreteColleague都复杂。