介绍
用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
参与者
- Mediator: 抽象中介者。定义了同事对象到中介者对象之间的接口。
- ConcreteMediator: 具体中介者。实现抽象中介者的方法，它需要知道所有的具体同事类，同时需要从具体的同事类那里接收信息，并且向具体的同事类发送信息。
- Colleague: 抽象同事类。
- ConcreteColleague: 具体同事类。每个具体同事类都只需要知道自己的行为即可，但是他们都需要认识中介者。
实现代码
enum{
Widget_A,
Widget_B,
};
class Widget;
class Meadiator{
public:
virtual void showMsg(std::string msg,Widget *meadiator) = 0;
};
class Widget{
public:
Widget(int id_,Meadiator *meadiator1)
{
id = id_;
meadiator = meadiator1;
}
virtual void showMe(std::string) = 0;
int getId()
{
return id;
}
public:
Meadiator *meadiator;
int id;
};
class WidgetA:public Widget{
public:
WidgetA(int id,Meadiator *meadiator1):Widget(id,meadiator1)
{
}
void showMe(std::string msg) override
{
std::cout<<"A: "<<msg<<std::endl;
}
void showMsg(std::string msg)
{
meadiator->showMsg(msg,this);
}
};
lass WidgetB:public Widget{
public:
WidgetB(int id,Meadiator *meadiator1):Widget(id,meadiator1)
{
}
void showMe(std::string msg) override
{
std::cout<<"B: "<<msg<<std::endl;
}
void showMsg(std::string msg)
{
meadiator->showMsg(msg,this);
}
};
class ConcreteMeadiator: public Meadiator{
public:
void SetWidgetA(WidgetA *widgetA1)
{
widgetA = widgetA1;
}
void SetWidgetB(WidgetB *widgetB1)
{
widgetB = widgetB1;
}
void showMsg(std::string msg,Widget *widget) override
{
if(widget->getId() == Widget_A)
{
widgetA->showMe(msg);
}else if(widget->getId() == Widget_B)
{
widgetB->showMe(msg);
}
}
private:
WidgetA *widgetA;
WidgetB *widgetB;
};
int main()
{
ConcreteMeadiator meadiator;
auto *widgetA = new WidgetA(Widget_A,&meadiator);
auto *widgetB = new WidgetB(Widget_B,&meadiator);
meadiator.SetWidgetA(widgetA);
meadiator.SetWidgetB(widgetB);
widgetA->showMsg("你好啊！");
widgetB->showMsg("我很好！");
}
输出结果
A: 你好啊！
B: 我很好！
特点
- 简化了对象之间的关系，将系统的各个对象之间的相互关系进行封装，将各个同事类解耦，使系统成为松耦合系统。
- 减少了子类的生成。
- 可以减少各同事类的设计与实现。
- 由于中介者对象封装了系统中对象之间的相互关系，导致其变得非常复杂，使得系统维护比较困难。
网友评论