设计模式-中介者模式用一个中介对象来封装一些了的对象交互。各对象不需要显示的相互引用。中介就是所有的调和者,符合最小知道原则，把交互功能几种在中介者身上。优点：灵活性高，因为将同事类进行了解耦，使其不必有关联性；降低了类的复杂度，将一对多转化成了一对一；缺点：过度集中化，这是中介者模式潜在的缺点。如果同事对象多了，交互也复杂了。那么这些交互全部集中到中介者对象中，会导致中介者对象十分臃肿，难以管理和维护。典型例子：电脑主板（主线） 与 CPU、银盘、内存等的交互。

来个类图：

中介需要知道所有的同事，同事也需要知道中介，同事有什么事情就告诉中介，中介会协调另外同事进行动作。

下面是一个 模拟现实买房的例子来举例中介者模式：

1：先声明个房地产中介的接口

这个中介接口中 定义了很多同事类还有很多动作

/*** 房地产中介 - 中介者* 中介就一个功能，沟通*/
public abstract class RealtyMediator {//中介者都有同事者的信息//同事类 - 银行protected BankColleague bankColleague;//同事类 - 买房者protected BuyerColleague buyerColleague;//同事类 - 业主protected OwnerColleague ownerColleague;/*** 想售楼*/abstract void wantToSale();/*** 想买楼*/abstract void wantToBuy();/*** 同意卖楼*/abstract void agreeToSale();/*** 想要贷款*/abstract void wantToBorrow();/*** 同意贷款*/abstract void agreeToBorrow();//get and setpublic BankColleague getBankColleague() {return bankColleague;}public void setBankColleague(BankColleague bankColleague) {this.bankColleague = bankColleague;}public BuyerColleague getBuyerColleague() {return buyerColleague;}public void setBuyerColleague(BuyerColleague buyerColleague) {this.buyerColleague = buyerColleague;}public OwnerColleague getOwnerColleague() {return ownerColleague;}public void setOwnerColleague(OwnerColleague ownerColleague) {this.ownerColleague = ownerColleague;}}

2：具体的中介 - 某链J中介公司

此类实现了几个动作，比如 wantToSale（）想卖房方法是业主调用的，调用之后，是去通知买房的人的wantToBuy()方法

/*** 某链J房地产中介公司*/
public class LjRealtyMediator extends RealtyMediator {@Overridevoid wantToSale() {System.out.println("中介：有房源了，看看买房者想不想买");buyerColleague.wantToBuy();}@Overridevoid wantToBuy() {System.out.println("中介：买房者想买了，再向业主确认下价格，看看卖不卖");ownerColleague.agreeToSale();}@Overridevoid agreeToSale() {System.out.println("中介：业主同意卖方了，告诉买房者，让他准备钱");buyerColleague.wantToBorrow();}@Overridevoid wantToBorrow() {System.out.println("中介：买房者想贷款，我去和银行说说");bankColleague.agreeToBorrow();}@Overridevoid agreeToBorrow() {System.out.println("中介： 银行同意贷款了，告诉买房者准备材料");buyerColleague.ready();}
}

3：同事类-接口

此接口就一个构造函数

/*** 中介者同事类*/
public abstract class Colleague {protected RealtyMediator realtyMediator;Colleague(RealtyMediator realtyMediator){this.realtyMediator = realtyMediator;}}

4：具体的同事类：

银行同事类

有个同意贷款的方法，通知中介 银行这边已经同意贷款了

/*** 银行 中介者模式同事类*/
public class BankColleague extends Colleague {BankColleague(RealtyMediator realtyMediator) {super(realtyMediator);System.out.println("银行 和 中介 一直都是合作方，他们很早就认识了");realtyMediator.setBankColleague(this);}/*** 同意贷款*/public void agreeToBorrow(){System.out.println("银行：同意贷款");realtyMediator.agreeToBorrow();}
}

业主同事类

有想卖房和同意卖房两个动作，都要告诉中介，让中介进行下一步

/*** 房屋出售的业主 - 中介者同事类*/
public class OwnerColleague extends Colleague{OwnerColleague(RealtyMediator realtyMediator) {super(realtyMediator);System.out.println("业主 想卖房 ，认识了中介");realtyMediator.setOwnerColleague(this);}//业主的动作/***  想售楼*/public void wantToSale(){System.out.println("业主： 想要卖房");realtyMediator.wantToSale();}/*** 同意卖房*/public void agreeToSale(){System.out.println("业主： 同意卖房");realtyMediator.agreeToSale();}}

买房人的同事类

/*** 购买者 - 中介者模型同事类*/
public class BuyerColleague extends Colleague {BuyerColleague(RealtyMediator realtyMediator) {super(realtyMediator);System.out.println("买房者:想买房 ，认识了中介");realtyMediator.setBuyerColleague(this);}/*** 想要买*/public void wantToBuy(){System.out.println("买房者:想要买房");realtyMediator.wantToBuy();}/*** 想要贷款*/public void wantToBorrow(){System.out.println("买房者:想要贷款");realtyMediator.wantToBorrow();}/*** 准备*/public void ready(){System.out.println("买房者:材料正在准备中...");}
}

以上都声明完了，接下来，就是紧张的测试了，看看怎么用吧。

 public static void main(String[] args) {System.out.println("角色初始化...");//声明一个房地产中介RealtyMediator realtyMediator = new LjRealtyMediator();//银行Colleague bank = new BankColleague(realtyMediator);//买房者Colleague buyer = new BuyerColleague(realtyMediator);//业主 卖房者Colleague owner = new OwnerColleague(realtyMediator);System.out.println();System.out.println("------------故事要发生了---------------");System.out.println();//业主想卖房((OwnerColleague) owner).wantToSale();}

运行结果：

角色初始化...
银行 和 中介 一直都是合作方，他们很早就认识了
买房者:想买房 ，认识了中介
业主 想卖房 ，认识了中介------------故事要发生了---------------业主： 想要卖房
中介：有房源了，看看买房者想不想买
买房者:想要买房
中介：买房者想买了，再向业主确认下价格，看看卖不卖
业主： 同意卖房
中介：业主同意卖方了，告诉买房者，让他准备钱
买房者:想要贷款
中介：买房者想贷款，我去和银行说说
银行：同意贷款
中介： 银行同意贷款了，告诉买房者准备材料
买房者:材料正在准备中...

例子已经演示完了，通过这个例子，我们也可以看到，同事类，其实也是我们的业务类，他只负责他自己的业务，他知道有个中介在那里，具体中介后面的操作，他也不关心，要他做的时候，中介自然会叫他做，

但是这个中介真的太辛苦了，太多事情要做了，如果他们的通讯种类再多几个的话，中介就太臃肿了，这也是中介者模式的弊端。

设计模式是种思路，它不一定很完美，但它真的很美。