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

中介者模式适合于组件之间过于耦合而不方便修改的情况。因为中介者模式强制组件之间只通过中介者交互，而不是组件之间直接交互，避免组件之间相互依赖紧密耦合，方便于修改。类所拥有的依赖关系越少， 就越易于修改、 扩展或复用。

因为交互都是通过中介者来实现，所以需要在中介者中定义交互的所有方法。

classDiagram
class ComponentA{
	-m:Mediator
	+ operationA()
}
class ComponentB{
	-m:Mediator
	+ operationB()
}
class Mediator{
	<<interface>>
	+ notify()
}
class ConcrateMediator{
	- ComponentA
	- ComponentB
	+ notify()
	+ operationA()
	+ operationB()
}
ComponentA --> Mediator
ConcrateMediator ..|> Mediator
ComponentB --> Mediator
ConcrateMediator *--> ComponentA
ConcrateMediator *--> ComponentB

代码实现：

// 抽象组件
public abstract class Plane {  
    protected Mediator mediator;  
  
    public void setMediator(Mediator mediator) {  
        this.mediator = mediator;  
    }  
  
    abstract void notifyMsg(String msg);  
  
    abstract void receiveMsg(String msg);  
}

public class PlaneA extends Plane {  
  
    @Override  
    public void notifyMsg(String msg) {  
        System.out.println("PlaneA 通知控制塔:" + msg);  
        mediator.notifyOtherPlane(this, msg);  
    }  
  
    @Override  
    public void receiveMsg(String msg) {  
        System.out.println("PlaneA 收到控制塔通知:" + msg);  
    }  
}


public class PlaneB extends Plane {  
  
    @Override  
    public void notifyMsg(String msg) {  
        System.out.println("PlaneB 通知控制塔:"+msg);  
        mediator.notifyOtherPlane(this,msg);  
    }  
  
    @Override  
    public void receiveMsg(String msg) {  
        System.out.println("PlaneB 收到控制塔通知:"+msg);  
    }  
}

// 抽象中介者
public interface Mediator {  
    void notifyOtherPlane(Plane plane, String msg);  
}

public class ControllerTower implements Mediator{  
    Plane planeA;  
    Plane planeB;  
  
    public void setPlaneA(Plane planeA) {  
        this.planeA = planeA;  
    }  
  
    public void setPlaneB(Plane planeB) {  
        this.planeB = planeB;  
    }  
  
    @Override  
    public void notifyOtherPlane(Plane plane, String msg) {  
        if(plane==planeA){  
            planeB.receiveMsg("PlanA 需要"+msg);  
        }else if(plane==planeB){  
            planeA.receiveMsg("PlanB 需要"+msg);  
        }  
    }  
}

Plane planeA=new PlaneA();  
Plane planeB=new PlaneB();  
ControllerTower tower=new ControllerTower();  
tower.setPlaneA(planeA);  
tower.setPlaneB(planeB);  
planeA.setMediator(tower);  
planeB.setMediator(tower);  
planeA.notifyMsg("起飞");

中介者模式的优点是减低组件间的耦合度，方便修改组件。

缺点是由于中介者需要定义组件间交互的所有方法，容易变成上帝对象。