概念
用来降低多个对象和类之间的通信复杂性。该模式用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，仅仅只需要把一个对象的请求交给它的中介者即可，从而使其耦合松散，而且可以独立地改变它们之间的交互。
优点：
降低了类的复杂度，将一对多转化成了一对一。(一个对象与多个对象交互变成与一个中介者交互)各个类之间的解耦。符合迪米特原则。
缺点：
中介者类会很庞大，变得复杂难以维护。
举例
import java.util.Hashtable;
public class User1{
public static void main(String[] args) {
//创建一个中介者
AbstractMediator mediator = new Mediator();
//创建两个同事
ColleagueA colleagueA = new ColleagueA(mediator);
ColleagueB colleagueB = new ColleagueB(mediator);
//中介者分别与每个同事建立联系
mediator.addColleague("ColleagueA", colleagueA);
mediator.addColleague("ColleagueB", colleagueB);
//同事们开始工作
colleagueA.self();
colleagueA.out();
//System.out.println("======================合作愉快，任务完成！\n");
colleagueB.self();
colleagueB.out();
//System.out.println("======================合作愉快，任务完成！");
}
}
// 同事类族:同时要能与中介者沟通
abstract class AbstractColleague {
protected AbstractMediator mediator;
/* 既然有中介者，那么每个具体同事必然要与中介者有联系，
* 否则就没必要存在于 这个系统当中，这里的构造函数相当
* 于向该系统中注册一个中介者，以取得联系
* 既然有中介者，那么每个具体同事必然要与中介者有联系，
* */
public AbstractColleague(AbstractMediator mediator) {
this.mediator = mediator;
}
// 在抽象同事类中添加用于与中介者取得联系（即注册）的方法
//可以不写
public void setMediator(AbstractMediator mediator) {
this.mediator = mediator;
}
}
// 具体A类同事
class ColleagueA extends AbstractColleague {
//每个具体同事都通过父类构造函数与中介者取得联系
public ColleagueA(AbstractMediator mediator) {
super(mediator);
}
//每个具体同事必然有自己分内的事，没必要与外界相关联
public void self() {
System.out.println("同事A --> 已完成自己分内的事情:A.self");
}
//每个具体同事总有需要与外界交互的操作，通过中介者来处理这些逻辑并安排工作
public void out() {
System.out.println("同事A --> 请求同事B做好分内工作:B.self");
super.mediator.execute("ColleagueB", "self");
System.out.println("请求工作已完成");
}
}
//具体B类同事
class ColleagueB extends AbstractColleague {
// 分配一个中介者
public ColleagueB(AbstractMediator mediator) {
super(mediator);
}
public void self() {
System.out.println("同事B --> 已完成自己分内的事情:B.self");
}
public void out() {
System.out.println("同事B --> 请求同事A做好分内工作:A.self.");
super.mediator.execute("ColleagueA", "self");
System.out.println("请求工作已完成");
}
}
// 中介者类族:
abstract class AbstractMediator {
//中介者肯定需要保持有若干同事的联系方式
// 同事名,所属同事类
protected Hashtable<String, AbstractColleague> colleagues
= new Hashtable<String, AbstractColleague>();
//中介者可以动态地与某个同事建立联系
//添加一个能被某中介者处理的同事
public void addColleague(String name, AbstractColleague c) {
this.colleagues.put(name, c);
}
//中介者也可以动态地撤销与某个同事的联系
public void deleteColleague(String name) {
this.colleagues.remove(name);
}
//中介者必须具备在同事之间处理逻辑、分配任务、促进交流的操作
public abstract void execute(String name, String method);
}
//具体中介者
class Mediator extends AbstractMediator{
//中介者最重要的功能，来回奔波与各个同事之间
// 为某个同事name分配某个任务method
public void execute(String name, String method) {
if("self".equals(method)){ //各自做好分内事
if("ColleagueA".equals(name)) {
ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");
colleague.self();
}else {
ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");
colleague.self();
}
}else { //与其他同事合作
if("ColleagueA".equals(name)) {
ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");
colleague.out();
}else {
ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");
colleague.out();
}
}
}
}
Output:
同事A --> 已完成自己分内的事情:A.self
同事A --> 请求同事B做好分内工作:B.self
同事B --> 已完成自己分内的事情:B.self
请求工作已完成
同事B --> 已完成自己分内的事情:B.self
同事B --> 请求同事A做好分内工作:A.self.
同事A --> 已完成自己分内的事情:A.self
请求工作已完成
