//抽象同事类
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 --> 做好自己分内的事情 ...");  }  //每个具体同事总有需要与外界交互的操作，通过中介者来处理这些逻辑并安排工作  public void out() {  System.out.println("同事A --> 请求同事B做好分内工作 ...");  super.mediator.execute("ColleagueB", "self");  }
}  //具体同事B
class ColleagueB extends AbstractColleague {  public ColleagueB(AbstractMediator mediator) {  super(mediator);  }  public void self() {  System.out.println("同事B --> 做好自己分内的事情 ...");  }  public void out() {  System.out.println("同事B --> 请求同事A做好分内工作  ...");  super.mediator.execute("ColleagueA", "self");  }
} 

中介者类族：

//抽象中介者
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{  //中介者最重要的功能，来回奔波与各个同事之间  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();  }  }  }
} 

测试类：

//测试类
public class Client {  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("======================合作愉快，任务完成！");  }
} 

测试结果：

同事A --> 做好自己分内的事情 ...
同事A --> 请求同事B做好分内工作 ...
同事B --> 做好自己分内的事情 ...
======================合作愉快，任务完成！  同事B --> 做好自己分内的事情 ...
同事B --> 请求同事A做好分内工作  ...
同事A --> 做好自己分内的事情 ...
======================合作愉快，任务完成！  

//抽象同事类
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 --> 做好自己分内的事情 ...");  }  //每个具体同事总有需要与外界交互的操作，通过中介者来处理这些逻辑并安排工作  public void out() {  System.out.println("同事A --> 请求同事B做好分内工作 ...");  super.mediator.execute("ColleagueB", "self");  }
}  //具体同事B
class ColleagueB extends AbstractColleague {  //舍去在构造函数中建立起与中介者的联系
//  public ColleagueB(AbstractMediator mediator) {
//      super(mediator);
//  }  public void self() {  System.out.println("同事B --> 做好自己分内的事情 ...");  }  public void out() {  System.out.println("同事B --> 请求同事A做好分内工作  ...");  super.mediator.execute("ColleagueA", "self");  }
} 

修改后的中介者：

//抽象中介者
abstract class AbstractMediator {  //中介者肯定需要保持有若干同事的联系方式  protected Hashtable<String, AbstractColleague> colleagues = new Hashtable<String, AbstractColleague>();  //中介者可以动态地与某个同事建立联系  public void addColleague(String name, AbstractColleague c) {  // 在中介者这里帮助具体同事建立起于中介者的联系  c.setMediator(this);  this.colleagues.put(name, c);  }     //中介者也可以动态地撤销与某个同事的联系  public void deleteColleague(String name) {  this.colleagues.remove(name);  }  //中介者必须具备在同事之间处理逻辑、分配任务、促进交流的操作  public abstract void execute(String name, String method);
} 

//测试类
public class Client {  public static void main(String[] args) {  //创建一个中介者  AbstractMediator mediator = new Mediator();  //不用构造函数为具体同事注册中介者来取得联系了
//      ColleagueA colleagueA = new ColleagueA(mediator);
//      ColleagueB colleagueB = new ColleagueB(mediator);  ColleagueA colleagueA = new ColleagueA();  ColleagueB colleagueB = new ColleagueB();  //中介者分别与每个同事建立联系  mediator.addColleague("ColleagueA", colleagueA);  mediator.addColleague("ColleagueB", colleagueB);  //同事们开始工作  colleagueA.self();  colleagueA.out();  System.out.println("======================合作愉快，任务完成！\n");  colleagueB.self();  colleagueB.out();  System.out.println("======================合作愉快，任务完成！");  }
} 

本文来自：http://haolloyin.blog.51cto.com/1177454/333810/