中介者
中介者模式：用一個中介對象來封裝一系列的對象交互欠橘，中介者使各對象不需要顯式地相互引用涛酗，從而使其耦合松散欺矫，而且可以獨立地改變它們之間的交互租谈。中介者模式又稱為調(diào)停者模式篮奄，它是一種對象行為型模式。

//創(chuàng)建門派抽象類

package com.md.tertium;

//門派抽象類
public abstract class School {
  protected IPatternAlliance patternAlliance;

  public School(IPatternAlliance patternAlliance) {
      super();
      this.patternAlliance = patternAlliance;
  }
//防御
  public void defense() {
      System.out.println( getName() + "防御" );
  }
  //攻擊
  public void attack(School school) {
      System.out.println( getName() + "攻擊" + school.getName() );
  }

  //有了中介者割去，將由中介者處理
  public void attackByPatternAlliance(School school) {
      patternAlliance.resolveAttack( this, school );
  }

  //門派攻擊
  public void defenseByPatternAlliance() {
      patternAlliance.attack( this );
  }

  public abstract String getName();
}


package com.md.tertium;

//中介者
public class MediatorSchool extends School {

  public MediatorSchool(IPatternAlliance patternAlliance) {
      super( patternAlliance );
  }

  @Override
  public String getName() {
      return "中介者神閣";
  }
}


package com.md.tertium;

public class CommandSchool extends School {
  public CommandSchool(IPatternAlliance patternAlliance) {
      super( patternAlliance );
  }

  @Override
  public String getName() {
      return "命令門";
  }
}
package com.md.tertium;

public class SingletonSchool extends School {
  public SingletonSchool(IPatternAlliance patternAlliance) {
      super( patternAlliance );
  }

  @Override
  public String getName() {
      return "單例宗";
  }
}
package com.md.tertium;

public class StrategySchool extends School {
  public StrategySchool(IPatternAlliance patternAlliance) {
      super( patternAlliance );
  }

  @Override
  public String getName() {
      return "策略";
  }

}
package com.md.tertium;

import java.util.List;

//模式聯(lián)盟 中介者接口
public interface IPatternAlliance {
  //提供一個加入聯(lián)盟的接口
  public abstract void add(School school);

  //防御聯(lián)盟
  public abstract void resolveAttack(School activeSide, School passiveSide);

  //攻擊聯(lián)盟
  public abstract void attack(School passiveSide);
}
package com.md.tertium;

import java.util.LinkedList;
import java.util.List;

//聯(lián)盟模式的具體實現(xiàn)
public class PatternAlliance implements IPatternAlliance {

  private List <School> schoolList = new LinkedList <School>();

  @Override
  public void add(School school) {
      //加入聯(lián)盟
      schoolList.add( school );
  }

  @Override
  public void resolveAttack(School activeSide, School passiveSide) {
      if (schoolList.contains( passiveSide )) {
          System.out.println( "被攻方" + passiveSide.getName() + "已加入聯(lián)盟窟却，聯(lián)盟將齊力防御！" );
          for (School school : schoolList) {
              school.defense();
          }
      } else {
          System.out.println( "被攻方" + passiveSide.getName() + "未加入聯(lián)盟劫拗，聯(lián)盟不給予防御幫助间校！" );
          passiveSide.defense();
      }
  }

  @Override
  public void attack(School passiveSide) {
      if (schoolList.contains( passiveSide ) && schoolList.contains( passiveSide )) {
          System.out.println( "主攻方" + passiveSide.getName() + "以及被攻方" + passiveSide.getName() + "都已加入聯(lián)盟，不允許內(nèi)訌页慷！" );
      } else if (schoolList.contains( passiveSide ) && !schoolList.contains( passiveSide )) {
          System.out.println( "主攻方" + passiveSide.getName() + "已加入聯(lián)盟憔足，被攻方" + passiveSide.getName() + "不在聯(lián)盟之中，將集體攻打該門派酒繁！" );
          for (School school : schoolList) {
              school.attack( passiveSide );
          }
      } else {
          System.out.println( "主攻方" + passiveSide.getName() + "未加入聯(lián)盟滓彰，聯(lián)盟無權(quán)干預(yù)此事！" );
          passiveSide.attack( passiveSide );
      }
  }
}
package com.md.tertium;

public class Main {
  public static void main(String[] args) {
//        School singletonSchool = new SingletonSchool();
//        School commandSchool = new CommandSchool();
//        School mediatorSchool = new MediatorSchool();
//
//        singletonSchool.attack( mediatorSchool );
//        commandSchool.attack( mediatorSchool );
//
//        mediatorSchool.defense();
      IPatternAlliance patternAlliance = new PatternAlliance();

      School singletonSchool = new SingletonSchool( patternAlliance );
      School commandSchool = new CommandSchool( patternAlliance );
      School mediatorSchool = new MediatorSchool( patternAlliance );

      School strategySchool = new StrategySchool( patternAlliance );

      //策略宮沒有被聯(lián)盟收留
      patternAlliance.add( mediatorSchool );
      patternAlliance.add( commandSchool );
      patternAlliance.add( singletonSchool );

      singletonSchool.attackByPatternAlliance( mediatorSchool );
      commandSchool.attackByPatternAlliance( mediatorSchool );
      System.out.println( "------------------------------------------------------" );
      mediatorSchool.attackByPatternAlliance( strategySchool );
      System.out.println( "------------------------------------------------------" );
      strategySchool.attackByPatternAlliance( mediatorSchool );
      mediatorSchool.defenseByPatternAlliance();
      System.out.println( "------------------------------------------------------" );
  }
}

《中介者模式》針對的問題是州袒，解決一系列對象之間復(fù)雜的耦合關(guān)系揭绑，這一系列對象往往是“多對多”的耦合關(guān)系，《中介者模式》采用一個中介者對象將這一系列對象集中管理，而各個對象也將自己與其它對象的交互行為委托給中介者處理他匪，從而減少這一系列對象之間的耦合菇存。
它的優(yōu)點倒是非常明顯，清除了一系列對象之間復(fù)雜的耦合關(guān)系邦蜜，并且中介者可以控制這一系列對象的行為依鸥，統(tǒng)一管理。
《中介者模式》的缺點是悼沈，由于中介者負(fù)責(zé)著一系列對象的交互與控制贱迟，所以中介者的類會非常復(fù)雜，而且一旦中介者類無法正常工作絮供，那么所有將行為委托給中介者的類都將會出現(xiàn)問題衣吠，所以在使用的時候還是要特別小心。