Mediator

中介者模式：用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

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

Mediator的出现减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator。

由于把对象如何协作进行了抽象，将中介者作为一个独立的概念并将其封装到一个对象中，这样关注的对象就从对象各自本身的行为转移到它们之间的交互中，也就是站在一个更宏观的角度去看待系统。

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

中介者一般应用于一组对象以定义良好但复杂的方式进行通信的场合，以及定制一个分布在多个类的行为，而又不想生成太多的子类的场合。

Mediator：抽象中介者，定义了同事对象到中介对象的接口。

ConcreteMediator：具体中介者，实现了抽象类的方法。它需要知道所有具体的同事类，并从某个具体同事类接收消息，向某个具体同事类发送消息。

Colleague：抽象同事类。

ConcreteColleague：具体同事类，每个同事类都知道自己的行为，而不了解其它同事类的行为，但都认识中介对象。

1 //抽象中介者类
2 public abstract class Mediator {
3 
4     //定义一个抽象的发送消息的方法，得到同事对象和发送消息。
5     public abstract void send(String message, Colleague colleague);
6     
7 }

 1 //抽象同事类
 2 public abstract class Colleague {
 3     
 4     protected Mediator mediator;
 5     
 6     //得到中介者
 7     public Colleague(Mediator mediator){
 8         this.mediator = mediator;
 9     }
10     
11 }

 1 class ConcreteColleague1 extends Colleague{
 2 
 3     public ConcreteColleague1(Mediator mediator) {
 4         super(mediator);
 5     }
 6     
 7     //发送消息就由中介者发出
 8     public void sendMsg(String msg){
 9         mediator.send(msg, this);
10     }
11     
12     public void inform(String msg){
13         System.out.println("同事1  得到信息：" + msg);
14     }
15     
16 }

 1 class ConcreteColleague2 extends Colleague{
 2 
 3     public ConcreteColleague2(Mediator mediator) {
 4         super(mediator);
 5     }
 6     
 7     public void sendMsg(String msg){
 8         mediator.send(msg, this);
 9     }
10     
11     public void inform(String msg){
12         System.out.println("同事2  得到信息：" + msg);
13     }
14     
15 }

 1 class ConcreteMediator extends Mediator{
 2 
 3     private ConcreteColleague1 concreteColleague1;
 4     
 5     private ConcreteColleague2 concreteColleague2;
 6     
 7     public void setConcreteColleague1(ConcreteColleague1 concreteColleague1) {
 8         this.concreteColleague1 = concreteColleague1;
 9     }
10 
11     public void setConcreteColleague2(ConcreteColleague2 concreteColleague2) {
12         this.concreteColleague2 = concreteColleague2;
13     }
14 
15     //根据对象做出选择判断，通知对象。
16     @Override
17     public void send(String message, Colleague colleague) {
18         
19         if(colleague == concreteColleague1){
20             concreteColleague2.inform(message);
21         }else{
22             concreteColleague1.inform(message);
23         }
24         
25     }
26     
27 }

 1     public static void main(String[] args) {
 2         
 3         ConcreteMediator cm = new ConcreteMediator();
 4         
 5         //让两个同事类认识中介者
 6         ConcreteColleague1 c1 = new ConcreteColleague1(cm);
 7         
 8         ConcreteColleague2 c2 = new ConcreteColleague2(cm);
 9         
10         //中介者认识各个具体同事类的对象
11         cm.setConcreteColleague1(c1);
12         
13         cm.setConcreteColleague2(c2);
14         
15         //具体同事类发送的消息都是由中介者转发
16         c1.sendMsg("你吃饭了吗？");
17         
18         c2.sendMsg("没呢，一起出去吃吧！");
19     }

打印结果：

同事2 得到信息：你吃饭了吗？
同事1 得到信息：没呢，一起出去吃吧！