mediator中介者设计模式（行为模式）

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

适用性：
• 1）系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。
• 2）一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
• 3）一个对象引用其他很多对象并且直接与这些对象通信 ,导致难以复用该对象。
• 4）想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。可以通过引入中介者类来实现，在中介者中定义对象交互的公共行为，如果需要改变行为则可以增加新的中介者类。

为什么要使用中介者模式
一般来说，同事类之间的关系是比较复杂的，多个同事类之间互相关联时，他们之间的关系会呈现为复杂的网状结构，这是一种过度耦合的架构，即不利于类的复用，也不稳定。例如在下图中，有六个同事类对象，假如对象1发生变化，那么将会有4个对象受到影响。如果对象2发生变化，那么将会有5个对象受到影响。也就是说，同事类之间直接关联的设计是不好的。

如果引入中介者模式，那么同事类之间的关系将变为星型结构，从图中可以看到，任何一个类的变动，只会影响的类本身，以及中介者，这样就减小了系统的耦合。一个好的设计，必定不会把所有的对象关系处理逻辑封装在本类中，而是使用一个专门的类来管理那些不属于自己的行为。

结构

参与者

• Mediator:中介者定义一个接口用于与各同事（Colleague）对象通信。
• ConcreteMediator: 具体中介者通过协调各同事对象实现协作行为。了解并维护它的各个同事。
• Colleague class: 定义同事类接口,定义各同事的公有方法.

• 具体同事类ConcreteColleague: 实现抽象同事类中的方法。每一个同时类需要知道中介者对象；每个具体同事类只需要了解自己的行为，而不需要了解其他同事类的情况。每一个同事对象在需与其他的同事通信的时候，与它的中介者通信。

  协作
  同事向一个中介者对象发送和接收请求。中介者在各同事间适当地转发请求以实现协作行为

效果
中介者模式的优点：
1) 减少了子类生成: Mediator将原本分布于多个对象间的行为集中在一起。改变这些行为只需生成Mediator的子类即可。这样各个Colleague类可被重用。
2) 简化各同事类的设计和实现 : 它将各同事类Colleague解耦，Mediator有利于各Colleague间的松耦合. 你可以独立的改变和复用各Colleague类和Mediator类。
3) 它简化了对象协议: 用Mediator和各Colleague间的一对多的交互来代替多对多的交互。一对多的关系更易于理解、维护和扩展。
4) 它对对象如何协作进行了抽象 将中介作为一个独立的概念并将其封装在一个对象中，使你将注意力从对象各自本身的行为转移到它们之间的交互上来。这有助于弄清楚一个系统中的对象是如何交互的。
5) 它使控制集中化中介者模式将交互的复杂性变为中介者的复杂性。
中介者模式的缺点：
因为中介者封装了协议，即在具体中介者类中包含了同事之间的交互细节，可能会导致具体中介者类非常复杂，这可能使得中介者自身成为一个难于维护的庞然大物。

实现

abstract class AbstractColleague {  
    protected int number;  

    public int getNumber() {  
        return number;  
    }  

    public void setNumber(int number){  
        this.number = number;  
    }  
    //抽象方法，修改数字时同时修改关联对象  
    public abstract void setNumber(int number, AbstractColleague coll);  
}  

class ColleagueA extends AbstractColleague{  
    public void setNumber(int number, AbstractColleague coll) {  
        this.number = number;  
        coll.setNumber(number*100);  
    }  
}  

class ColleagueB extends AbstractColleague{  

    public void setNumber(int number, AbstractColleague coll) {  
        this.number = number;  
        coll.setNumber(number/100);  
    }  
}  

public class Client {  
    public static void main(String[] args){  

        AbstractColleague collA = new ColleagueA();  
        AbstractColleague collB = new ColleagueB();  

        System.out.println("==========设置A影响B==========");  
        collA.setNumber(1288, collB);  
        System.out.println("collA的number值："+collA.getNumber());  
        System.out.println("collB的number值："+collB.getNumber());  

        System.out.println("==========设置B影响A==========");  
        collB.setNumber(87635, collA);  
        System.out.println("collB的number值："+collB.getNumber());  
        System.out.println("collA的number值："+collA.getNumber());  
    }  
}  
//类A和类B通过直接关联发生关系，如果使用中介者模式，类A和类B就不可以直接关联，通过中介者达到关联的目的

abstract class AbstractColleague {  
    protected int number;  

    public int getNumber() {  
        return number;  
    }  

    public void setNumber(int number){  
        this.number = number;  
    }  
    //注意这里的参数不再是同事类，而是一个中介者  
    public abstract void setNumber(int number, AbstractMediator am);  
}  

class ColleagueA extends AbstractColleague{  

    public void setNumber(int number, AbstractMediator am) {  
        this.number = number;  
        am.AaffectB();  
    }  
}  

class ColleagueB extends AbstractColleague{  

    @Override  
    public void setNumber(int number, AbstractMediator am) {  
        this.number = number;  
        am.BaffectA();  
    }  
}  

abstract class AbstractMediator {  
    protected AbstractColleague A;  
    protected AbstractColleague B;  

    public AbstractMediator(AbstractColleague a, AbstractColleague b) {  
        A = a;  
        B = b;  
    }  

    public abstract void AaffectB();  

    public abstract void BaffectA();  

}  
class Mediator extends AbstractMediator {  

    public Mediator(AbstractColleague a, AbstractColleague b) {  
        super(a, b);  
    }  

    //处理A对B的影响  
    public void AaffectB() {  
        int number = A.getNumber();  
        B.setNumber(number*100);  
    }  

    //处理B对A的影响  
    public void BaffectA() {  
        int number = B.getNumber();  
        A.setNumber(number/100);  
    }  
}  

public class Client {  
    public static void main(String[] args){  
        AbstractColleague collA = new ColleagueA();  
        AbstractColleague collB = new ColleagueB();  

        AbstractMediator am = new Mediator(collA, collB);  

        System.out.println("==========通过设置A影响B==========");  
        collA.setNumber(1000, am);  
        System.out.println("collA的number值为："+collA.getNumber());  
        System.out.println("collB的number值为A的10倍："+collB.getNumber());  

        System.out.println("==========通过设置B影响A==========");  
        collB.setNumber(1000, am);  
        System.out.println("collB的number值为："+collB.getNumber());  
        System.out.println("collA的number值为B的0.1倍："+collA.getNumber());  

    }  
} 

代码部分参考于：http://blog.youkuaiyun.com/zhengzhb/article/details/7430098