//Mediator 模式提供将对象间 的交互和通讯封装在一个类中,各个对象间的通信不必显势去声明和引用,大大降低了系统 的复杂性能
//
//例如 图中 ConcreteColleagueA 和 ConcreteColleagueB 之间的交互就可以通过 ConcreteMediator 提供的
//DoActionFromAtoB 来处理,ConcreteColleagueA 和 ConcreteColleagueB 不必维护对各自的引
//用,甚至它们也不知道各个的存在。Mediator通过这种方式将多对多的通信简化为了一 (Mediator )对多(Colleague )的通信。
//
//代码说明
//Mediator 模式的实现关键就是将对象 Colleague 之间的通信封装到一个类种单独处理,
//为了模拟 Mediator 模式的功能,这里给每个 Colleague 对象一个 string 型别以记录其状态,
//并通过状态改变来演示对象之间的交互和通信。这里主要就 Mediator 的示例运行结果给出
//分析:
// 1 )将ConcreteColleageA 对象设置状态“old ”,ConcreteColleageB 也设置状态“old ”;
//
// 2 )ConcreteColleageA 对象改变状态,并在 Action 中和 ConcreteColleageB 对象进行通信,并改变 ConcreteColleageB 对象的状态为“new ”;
//
// 3 )ConcreteColleageB 对象改变状态,并在 Action 中和 ConcreteColleageA 对象进行通信,并改变 ConcreteColleageA 对象的状态为“new ”;
//
// 注意到,两个 Colleague 对象并不知道它交互的对象,并且也不是显示地处理交互过程,这一切都是 通过 Mediator 对象完成的,示例程序运行的结
//果也正是证明了这一点。
//两个 Colleague 对象并不知道它交互的对象,并且也不是显示地处理交互过程,这一切都是 通过 Mediator 对象完成的,
//Mediator 模式的实现关键就是将对象 Colleague 之间的通信封装到一个类种单独处理,
//中介者模式
//通过在类A中引入中介者类 实现A子类——>中介者类的通信 在中介者类中引入A子类 实现中介者类——>A子类的通信
//将多对多的通信 转变成一对多
#include <string>
using namespace std;
class Mediator;
class Colleage //通信
{
public:
virtual ~Colleage(){}
virtual void Aciton() = 0;
int a;
protected:
Colleage(){}
Colleage(Mediator* mdt){this->_mdt = mdt;}
Mediator* _mdt;//桥梁模式--
};
class Mediator //抽象中介者
{
public:
virtual ~Mediator(){}
virtual void DoActionFromAtoB() = 0;
virtual void DoActionFromBtoA() = 0;
protected:
Mediator(){}
};
class ConcreteColleageA:public Colleage //通信A
{
public:
ConcreteColleageA(){}
ConcreteColleageA(Mediator* mdt,int t):Colleage(mdt){a = t;}//父类的成员变量不能在初始化列表初始化
~ConcreteColleageA(){}
virtual void Aciton()
{
_mdt->DoActionFromAtoB();//中介者实现通信
}
};
class ConcreteColleageB:public Colleage //通信B
{
public:
ConcreteColleageB(){}
ConcreteColleageB(Mediator* mdt,int t):Colleage(mdt){a = t;}
~ConcreteColleageB(){}
virtual void Aciton()
{
_mdt->DoActionFromBtoA();
}
};
class ConcreteMediator:public Mediator //具体中介者 在此类实现AB通信
{
public:
ConcreteMediator(){}
ConcreteMediator(Colleage* clgA,Colleage* clgB):_clgA(clgA),_clgB(clgB){}
~ConcreteMediator(){}
virtual void DoActionFromAtoB(){_clgB->a = _clgA->a;}
virtual void DoActionFromBtoA(){_clgA->a = _clgB->a;}
void SetConcreteColleageA(Colleage* clgA){this->_clgA = clgA;}
void SetConcreteColleageB(Colleage* clgB){this->_clgB = clgB;}
Colleage* GetConcreteColleageA(){return _clgA;}
Colleage* GetConcreteColleageB(){return _clgB;}
private:
Colleage* _clgA;
Colleage* _clgB;
};
void Mediator_test()
{
ConcreteMediator* m = new ConcreteMediator();
ConcreteColleageA* c1 = new ConcreteColleageA(m,3);
ConcreteColleageB* c2 = new ConcreteColleageB(m,4);
m->SetConcreteColleageA(c2);
m->SetConcreteColleageB(c2);
c1->Aciton(); //B得到A数据 虽然是调用的A函数 实际却通过中介者来完成
c2->Aciton(); //A得到B数据
}