定义

用一个中介对象来封装一系列的对象的交互。中介者使各对象不须要显示地相互使用，从而使其耦合松散，并且能够独立的改变他们之间的交互。

案例

比方有一个图像界面，在界面上有一个输入框LineEdit，有个一个列表框ListBox，有一个buttonButton。当输入框LineEdit没有内容的时候，button是灰显，不可用的，当在LineEdit输入了正确的选项后，ListBox也会跳转到改选项，Button被激活，能够操作。相同ListBox也能够选择不同的选项，改变LineEdit的内容，当Button能够使用的时候能够删除被选中的选项，这样各个窗体间有比較强的依赖关系，能够通过将集体行为封装在一个单独的中介者Mediator对象中来避免这个问题：

Mediator定义了中介类的一个接口：

1. class Mediator {
2. public:
3. virtual void showDialog() = 0;
4. virtual void widgetChanged(Widget*) = 0;
6. protected:
7. Mediator();
8. virtual void createWidgets() = 0;
9. };

Widget是全部窗体类的基类：

1. class Widget {
2. public:
3. Widget(Mediator* mediator) {
   m_mediator = mediator; }
4. virtual void changed(){
   }
5. Mediator* mediator() const {
   return m_mediator; }
7. private:
8. Mediator* m_mediator;
9. };

LineEdit类是一个文字输入窗体类：

1. class LineEdit : public Widget {
2. public:
3. LineEdit(Mediator*);
4. virtual void changed();
5. void setText(const string& text);
6. string text() const;
8. private:
9. string m_text;
10. };
12. void LineEdit::changed()
13. {
14. mediator()->widgetChanged(this);
15. }

Button和ListBox都是继承自Widget的类，并实现了自己独有的操作。

如今创建一个DialogMediator类把全部的窗体类联系起来：

1. class DialogMediator : public Mediator {
2. public:
3. virtual void widgetChanged(Widget* widget);
4. virtual void showDialog();
6. protected:
7. virtual void createWidgets();
9. private:
10. LineEdit* m_lineEdit;
11. ListBox* m_listBox;
12. Button* m_button;
13. };
15. void DialogMediator::createWidgets()
16. {
17. m_lineEdit = new LineEdit();
18. ...
19. }
21. void DialogMediator::widgetChanged(Widget* widget)
22. {
23. if(widget == m_lineEdit)
24. {
25. m_listBox->setSelection(m_lineEdit->text());
26. m_button->setEnable(true);
27. }
28. else if(m_listBox)
29. {
30. m_lineEdit->setText(m_listBox->getSeletion());
31. m_button->setEnable(true);
32. }
33. else
34. {
35. m_lineEdit->setText("");
36. m_listBox->setSelection(lastOne);
37. }
38. }

1. DialogMediator mediator;
2. mediator.createWidgets();
3. mediator.showDialog();

适用性

• 一组对象以定义良好可是通过复杂的方式进行通信，产生的依赖结构混乱
• 一个对象引用其它非常多对象而且直接与这些对象进行通信，导致难以复用该对象
• 想定制一个分布在多个类中的行为，而不想生成太多的子类

优缺点

1. 降低了子类的生成
2. 将各个类进行了解耦
3. 简化了对象协议，一对多的关系易于理解
4. 对对象怎样协作进行了抽象
5. 使控制集中化，使得中介者类自身庞大，难于维护