设计模式之调停者模式

调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显引用，从而使他们可以较松散的耦合。但这些对象中的某些对象之间的作用发生改变时，不会
立即影响到其他的一些对象之间的相互引用。从而保证这些相互作用可以彼此独立的变化。

 

 

代码：

public class Test {
 public static void main(String[] args) {
  ConcreteMediator m = new ConcreteMediator();  // 调停者
  
  ArrayList<Colleague> colleagues = new ArrayList<Colleague>();
  Colleague c1 = new ConcreteColleague1(m);
  Colleague c2 = new ConcreteColleague2(m);
  colleagues.add(c1);
  colleagues.add(c2);
  
  m.createColleagues(colleagues); // 调停者拥有所有的同事对象
  
  m.colleagueChanged(c1);    // 由调停者发起变化，通知所有（或某些）同事对象所发生的变化
 }
}

abstract class Colleague {
 private Mediator m; 
 public Colleague (Mediator m) {
  this.m = m;
 }
 
 protected abstract void action();
 
 public void change() {
  m.colleagueChanged(this);
 }
}
class ConcreteColleague1 extends Colleague {
 
 public ConcreteColleague1(Mediator m) {
  super(m);
 }
 
 public void action () {
  System.out.println("concrete colleague1 action...");
 }
}
class ConcreteColleague2 extends Colleague {
 
 public ConcreteColleague2(Mediator m) {
  super(m);
 }
 
 public void action () {
  System.out.println("concrete colleague2 action...");
 }
}

abstract class Mediator {
 
 protected abstract void colleagueChanged(Colleague source);
 
}
class ConcreteMediator extends Mediator {
 
 private List<Colleague> list = new ArrayList<Colleague>();
 
 public void colleagueChanged (Colleague source) {
  for (Iterator<Colleague> iter = list.iterator(); iter.hasNext();) {
   iter.next().action();
  }
 }
 
 public void createColleagues(List<Colleague> colleagues) {
   for (Iterator<Colleague> iter = colleagues.iterator(); iter.hasNext();) {
    this.list.add(iter.next());
   }
 }
}