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

要想恰到好处地在一个系统里面使用设计模式，必须做到以下几点：
（1）完全了解面临的问题，这就是说要完全了解具体情况。如果不完全了解所面临的问题，怎么能谈得上解决问题呢？
（2）完全了解模式，这就是说要十分懂得理论。如果不完全懂得所使用的理论，怎么能够正确地应用这一理论呢？
（3）非常了解怎样使用设计模式解决实际问题，这就是说要将模式理论与具体系统需求情况相结合。如果设计师不知道一个设计模式怎样
     对系统设计有帮助的华，最好不要使用这个模式。不要只是因为想在简历上写上设计模式方面的经验就盲目地使用模式。

调停者模式就是一个很容易被滥用的模式。

//调停者模式包括以下几种角色
1、抽象调停者角色：定义出同事对象到调停者对象的接口，其中主要的方法是一个（或者多个）事件方法，在有些情况下，
   这个抽象对象可以省略。一般而言，这个角色由一个Java抽象类或者Java对象实现。
2、具体调停者角色：从抽象调停者继承而来，实现了抽象超类所声明的事件方法。具体调停者知晓所有的具体同事类，它从具体同事
   对象接受消息、向具体同事对象发出命令。一般而言，这个角色由一个具体Java类实现。
3、抽象同事类角色：定义出调停者到同事对象的接口。同事对象只知道调停者而不知道其余的同事对象。一般而言，这个角色由一个
   Java抽象类或者Java对象实现。
4、具体同事类角色：所有的具体同时类均从抽象同事类继承而来。每一个具体同事类都很清楚它自己在小范围内的行为，而不知到它
   在大范围内的目的。

//抽象类同事类   
       public abstract class Colleague{   
        private Mediator mediator;   
           
        public Colleague(Mediator m){   
            mediator =  m;   
        }   
           
        public Mediator getMediator(){   
            return mediator;   
        }   
           
        public abstract void action();   
           
        public void change(){   
            mediator.colleagueChanged(this);   
        }   
       }   
          
      //具体同事类   
      public class Colleague1 extends Colleague{   
        public Colleague1(Mediator m){   
            super(m);   
        }   
           
        public void action(){   
            System.out.println("This is an action from Colleague 1");   
        }   
      }   
         
      public class Colleague2 extends Colleague{   
        public Colleague2(Mediator m){   
            super(m);   
        }   
           
        public void action(){   
            System.out.println("This is an action from Colleague 2");   
        }   
      }   
         
      //抽象调停者角色   
      public class Mediator{   
        public abstract void colleagueChanged(Colleague c);   
           
        public static void main(String[] args){   
            ConcreteMediator mediator = new ConcreteMediator();   
               
            mediator.createConcreteMediator();   
            Colleague c1 = new Colleague1(mediator);   
            Colleague c2 = new Colleague2(mediator);   
            mediator.colleagueChanged(c1);   
        }   
      }   
       
    //具体调停者角色   
    public class ConcreteMediator extends Mediator{   
        private Colleague1 colleague1;   
        private Colleague2 colleague2;   
           
        public void colleagueChanged(Colleague c){   
            colleague1.action();   
            colleague2.action();   
        }   
           
        public void createConcreteMediator(){   
            colleague1 = new Colleague1(this);   
            colleague2 = new Colleague2(this);   
        }   
           
        public Colleague1 getColleague1(){   
            return colleague1;   
        }   
           
        public Colleague2 getColleague2(){   
            return colleague2;   
        }   
           
    }  

 //抽象类同事类
		   public abstract class Colleague{
		   	private Mediator mediator;
		   	
		   	public Colleague(Mediator m){
		   		mediator =  m;
		   	}
		   	
		   	public Mediator getMediator(){
		   		return mediator;
		   	}
		   	
		   	public abstract void action();
		   	
		   	public void change(){
		   		mediator.colleagueChanged(this);
		   	}
		   }
		   
		  //具体同事类
		  public class Colleague1 extends Colleague{
		  	public Colleague1(Mediator m){
		  		super(m);
		  	}
		  	
		  	public void action(){
		  		System.out.println("This is an action from Colleague 1");
		  	}
		  }
		  
		  public class Colleague2 extends Colleague{
		  	public Colleague2(Mediator m){
		  		super(m);
		  	}
		  	
		  	public void action(){
		  		System.out.println("This is an action from Colleague 2");
		  	}
		  }
		  
		  //抽象调停者角色
		  public class Mediator{
		  	public abstract void colleagueChanged(Colleague c);
		  	
		  	public static void main(String[] args){
		  		ConcreteMediator mediator = new ConcreteMediator();
		  		
		  		mediator.createConcreteMediator();
		  		Colleague c1 = new Colleague1(mediator);
		  		Colleague c2 = new Colleague2(mediator);
		  		mediator.colleagueChanged(c1);
		  	}
		  }
		
		//具体调停者角色
		public class ConcreteMediator extends Mediator{
			private Colleague1 colleague1;
			private Colleague2 colleague2;
			
			public void colleagueChanged(Colleague c){
				colleague1.action();
				colleague2.action();
			}
			
			public void createConcreteMediator(){
				colleague1 = new Colleague1(this);
				colleague2 = new Colleague2(this);
			}
			
			public Colleague1 getColleague1(){
				return colleague1;
			}
			
			public Colleague2 getColleague2(){
				return colleague2;
			}
			
		}

调停者模式的优点和缺点：
1、调停者模式的优点：
（1）适当使用调停者模式可以较少使用静态的继承关系，使得具体同事类可以更加容易地被复用。
（2）适当使用调停者模式可以避免同事之间的过渡耦合，使得调停类与同事类可以相对独立地演化。
（3）调停者模式将多对多的相互转化为一对多的相互作用，使得对象之间的关系更加易于维护个理解。
（4）调停者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。

2、调停者模式的缺点：
（1）调停者模式降低了同事对象的复杂性，代价是增加了调停者类的复杂性。当然，在很多情况下，设置
     一个调停者并不比不设置一个调停者更好
（2）调停者类经常充满了各个具体同事类的关系协调代码，这种代码常常是不能复用的。因此，具体同事类的
     复用是以调停者类的不可复用为代价的。
    
     显然，调停者模式为同事对象，而不是调停者对象提供了可扩展性，所以这个模式所提供的可扩展性是一种
     （向同事对象）倾斜的可扩展性。


在什么情况下使用调停者模式
大多数对模式的研究集中于模式应当在什么情况下使用，却往往忽视这些模式不应当在什么情况下使用。

1、不应当在责任划分混乱时使用

2、不应当对“数据类”和“方法类”使用