轉載自：
http://patmusing.blog.163.com/blog/static/1358349602010150177996/“Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction” – GoF
用一個中介對象來封裝一系列的對象交互。Mediator使各對象不需要顯示的相互引用，從而使其耦合松散，以便可以獨立地改變他們之間的交互。
Object-oriented design encourages the distribution of behavior among objects. Such distribution can result in an object structure with many connections between objects; in the worst case, every object ends up knowing about every other.
Though partitioning a system into many objects generally enhances reusability, proliferating interconnections tend to reduce it again. Lots of interconnections make it less likely that an object can work without the support of others—the system acts as though it were monolithic. Moreover, it can be difficult to change the system's behavior in any significant way, since behavior is distributed among many objects. As a result, you may be forced to define many subclasses to customize the system's behavior.
在軟件構建過程中，經常會出現多個對象相互關聯交互的情況，對象之間常常會維持一種復雜的引用關系，如果遇到一些需求的更改，這種直接的引用關系將面臨不斷的變化。在這種情況下，我們可以使用一個“中介對象”來管理對象間的關聯關系，避免相互交互的對象之間的緊耦合的引用關系，從而更好地駕馭變化。
依賴關系的轉化示例：
1. 5個類相互之間兩兩相互依賴； 1. 5各類彼此之間沒有直接的依賴關系；
2. 共有10個關系需要維護； 2. 共有5個關系需要維護；
3. 如果任意其中一個類發生了改 3. 如果任意其中一個類發生了改變，那么
變，那么另外4個類，度需要 只需要修改Mediator即可，其它4個
隨之改變； 類可以維持不變；
4. 如果要增加一個新類F，那么需要 4. 如果要增加一個類F，那么要維護的關系
維護的關系數量將變為15，并且 數量將變為6，原有的5個類不需要做任
原有的5個類均需要做相應改變。 和改變，僅需改變Mediator即可。
Applicability:
- A set of objects communicate in well-defined but complex ways. The resulting interdependencies are unstructed and difficult to understand.
- Resuing an object is difficult because it refers to and communicates with many other objects.
- A behavior that’s distributed between several classes should be customizable without a lot of subclassing.
Participants:
- Mediator:
Defines an interface for communicating with Colleague objects.
- ConcreteMediator:
Implements cooperative behavior by coordinatiing Colleague objects.
Knows and maintains its colleagues.
- Colleagues
Each Colleague class knows its Mediator object.
Each colleague communicates with its mediator whenever it would have otherwise communicated with another colleague.
業務示例：假定有如下圖所示的界面：
RadioButtons包含了4個單選，CheckBoxes包含了4個復選框，ComboBox中有4個選項。先假定：
如果RadioButtons中選擇了Roption1，那么CheckBoxes中的Coption1就會被選中，ComboBox中的ComOption1就會被選中；如果CheckBoxes中的COption1被選中，那么RadioButtons中的ROption1和ComboBox中的ComOption1就會被選中；如果ComboBox中的ComOption1被選中，那么RadioButtons中的ROption1和CheckBoxes中的Coption1就會被選中。以此類推。另外在這里，RadioButtons和其中的單選按鈕被看成是一個對象，4個單選按鈕可視為RadioButtons的4個狀態；CheckBoxes和ComboBox也是如此。
還有一個假設：
CheckBoxes和ComboBox分別只能選擇其中一項(即“復選框”也不能“復選”，與其實際功能不符，純為研究用)
優點：
- 將多對多的關系轉化為一對多的關系，使對象之間的關系更易于維護；
- 將對象的行為和協作抽象化。
缺點：
- 雖然降低了同事類的復雜性，但增加了調停者對象的復雜性；
- 同事類的復用性是以調停者類的不可復用為代價的。
C++實現代碼：
// Mediator.h
#include <string>
#include <iostream>
using namespace std;
// 前置聲明
class AbstractColleague;
// 抽象調停類
class AbstractMediator
{
public:
// 通知"同事"類，其參數aac為引發事件的對象
virtual void notify_colleagues(AbstractColleague *aac) = 0;
public:
virtual ~AbstractMediator()
{
cout << "in the destructor of AbstractMediator..." << endl;
}
};
// 抽象"同事"類
class AbstractColleague
{
protected:
AbstractMediator *mediator;
public:
AbstractColleague(AbstractMediator *mediator)
{
this->mediator = mediator;
}
~AbstractColleague()
{
cout << "in the destructor of AbstractColleague..." << endl;
}
public:
virtual void set_item_true(int i) = 0;
virtual int get_true_item() = 0;
void on_change(AbstractColleague *aac)
{
mediator->notify_colleagues(aac);
}
};
// 單選按鈕
class RadioButtons : public AbstractColleague
{
private:
bool rButton1;
bool rButton2;
bool rButton3;
bool rButton4;
public:
RadioButtons(AbstractMediator *mediator) : AbstractColleague(mediator)
{
rButton1 = false;
rButton2 = false;
rButton3 = false;
rButton4 = false;
}
~RadioButtons()
{
cout << "in the destructor of RadioButtons..." << endl;
}
public:
void set_item_true(int i)
{
rButton1 = false;
rButton2 = false;
rButton3 = false;
rButton4 = false;
switch(i)
{
case 1:
rButton1 = true;
break;
case 2:
rButton2 = true;
break;
case 3:
rButton3 = true;
break;
case 4:
rButton4 = true;
break;
default:
rButton1 = true;
}
}
int get_true_item()
{
if(rButton1) return 1;
if(rButton2) return 2;
if(rButton3) return 3;
if(rButton4) return 4;
return 1;
}
void onRadioButtonClick()
{
on_change(this);
}
};
// 復選框
class CheckBoxes : public AbstractColleague
{
private:
bool cBox1;
bool cBox2;
bool cBox3;
bool cBox4;
public:
CheckBoxes(AbstractMediator *mediator) : AbstractColleague(mediator)
{
cBox1 = false;
cBox2 = false;
cBox3 = false;
cBox4 = false;
}
~CheckBoxes()
{
cout << "in the destructor of CheckBoxes..." << endl;
}
public:
void set_item_true(int i)
{
cBox1 = false;
cBox2 = false;
cBox3 = false;
cBox4 = false;
switch(i)
{
case 1:
cBox1 = true;
break;
case 2:
cBox2 = true;
break;
case 3:
cBox3 = true;
break;
case 4:
cBox4 = true;
break;
default:
cBox1 = true;
}
}
int get_true_item()
{
if(cBox1) return 1;
if(cBox2) return 2;
if(cBox3) return 3;
if(cBox4) return 4;
return 1;
}
void onCheckBoxClick()
{
on_change(this);
}
};
// 下拉框
class ComboBox : public AbstractColleague
{
private:
bool cOpt1;
bool cOpt2;
bool cOpt3;
bool cOpt4;
public:
ComboBox(AbstractMediator *mediator) : AbstractColleague(mediator)
{
cOpt1 = false;
cOpt2 = false;
cOpt3 = false;
cOpt4 = false;
}
~ComboBox()
{
cout << "in the destructor of ComboxBox..." << endl;
}
public:
void set_item_true(int i)
{
cOpt1 = false;
cOpt2 = false;
cOpt3 = false;
cOpt4 = false;
switch(i)
{
case 1:
cOpt1 = true;
break;
case 2:
cOpt2 = true;
break;
case 3:
cOpt3 = true;
break;
case 4:
cOpt4 = true;
break;
default:
cOpt1 = true;
}
}
int get_true_item()
{
if(cOpt1) return 1;
if(cOpt2) return 2;
if(cOpt3) return 3;
if(cOpt4) return 4;
return 1;
}
void onComboBoxClick()
{
on_change(this);
}
};
// 具體調停類
class ConcreteMediator : public AbstractMediator
{
private:
RadioButtons* rbt;
CheckBoxes* cbx;
ComboBox* cbo;
public:
~ConcreteMediator()
{
cout << "in the destructor of ConcreteMediator..." << endl;
}
void set_colleagues(RadioButtons* rbt, CheckBoxes* cbx, ComboBox* cbo)
{
this->rbt = rbt;
this->cbx = cbx;
this->cbo = cbo;
}
void notify_colleagues(AbstractColleague *aac)
{
int i = aac->get_true_item();
rbt->set_item_true(i);
cbx->set_item_true(i);
cbo->set_item_true(i);
}
};
// Mediator.cpp
#include "Mediator.h"
int main(int argc, char **argv)
{
AbstractMediator* mediator = new ConcreteMediator();
RadioButtons* rbt = new RadioButtons(mediator);
CheckBoxes* cbx = new CheckBoxes(mediator);
ComboBox* cbo = new ComboBox(mediator);
dynamic_cast<ConcreteMediator*>(mediator)->set_colleagues(rbt, cbx, cbo);
// 下面兩行模擬RadioButtons的onClick事件觸發，并選中第個單選按鈕
rbt->set_item_true(1);
rbt->onRadioButtonClick();
cout << "Event triggered by the No.1 item of RadioButtons" << endl;
cout << "rButton" << rbt->get_true_item() << " \tis selected!" << endl;
cout << "cBox" << cbx->get_true_item() << " \t\tis selected accordingly!" << endl;
cout << "cOpt" << cbo->get_true_item() << " \t\tis selected accordingly!" << endl;
cout << "------------------------------------------------------" << endl;
// 下面兩行模擬CheckBoxes的onClick事件觸發，并選中第個復選框
cbx->set_item_true(2);
cbx->onCheckBoxClick();
cout << "Event triggered by the No.2 item of CheckBoxes" << endl;
cout << "rButton" << rbt->get_true_item() << " \tis selected accordingly!" << endl;
cout << "cBox" << cbx->get_true_item() << " \t\tis selected!" << endl;
cout << "cOpt" << cbo->get_true_item() << " \t\tis selected accordingly!" << endl;
cout << "------------------------------------------------------" << endl;
// 下面兩行模擬ComboBox的onClick事件觸發，并選中第個選項
cbo->set_item_true(3);
cbo->onComboBoxClick();
cout << "Event triggered by the No.3 item of ComboBox" << endl;
cout << "rButton" << rbt->get_true_item() << " \tis selected accordingly!" << endl;
cout << "cBox" << cbx->get_true_item() << " \t\tis selected accordingly!" << endl;
cout << "cOpt" << cbo->get_true_item() << " \t\tis selected!" << endl;
cout << "------------------------------------------------------" << endl;
delete mediator;
delete rbt;
delete cbx;
delete cbo;
return 0;
}
運行結果：
Event triggered by the No.1 item of RadioButtons
rButton1 is selected!
cBox1 is selected accordingly!
cOpt1 is selected accordingly!
------------------------------------------------------
Event triggered by the No.2 item of CheckBoxes
rButton2 is selected accordingly!
cBox2 is selected!
cOpt2 is selected accordingly!
------------------------------------------------------
Event triggered by the No.3 item of ComboBox
rButton3 is selected accordingly!
cBox3 is selected accordingly!
cOpt3 is selected!
------------------------------------------------------
in the destructor of ConcreteMediator...
in the destructor of AbstractMediator...
in the destructor of RadioButtons...
in the destructor of AbstractColleague...
in the destructor of CheckBoxes...
in the destructor of AbstractColleague...
in the destructor of ComboxBox...
in the destructor of AbstractColleague...
上述程序的UML類圖：
