中介者
    中介者模式：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

    2. //创建门派抽象类
    4. package com.md.tertium;
    6. //门派抽象类
    7. public abstract class School {
    8.   protected IPatternAlliance patternAlliance;
    10.   public School(IPatternAlliance patternAlliance) {
    11.       super();
    12.       this.patternAlliance = patternAlliance;
    13.   }
    14. //防御
    15.   public void defense() {
    16.       System.out.println( getName() + "防御" );
    17.   }
    18.   //攻击
    19.   public void attack(School school) {
    20.       System.out.println( getName() + "攻击" + school.getName() );
    21.   }
    23.   //有了中介者，将由中介者处理
    24.   public void attackByPatternAlliance(School school) {
    25.       patternAlliance.resolveAttack( this, school );
    26.   }
    28.   //门派攻击
    29.   public void defenseByPatternAlliance() {
    30.       patternAlliance.attack( this );
    31.   }
    33.   public abstract String getName();
    34. }
    37. package com.md.tertium;
    39. //中介者
    40. public class MediatorSchool extends School {
    42.   public MediatorSchool(IPatternAlliance patternAlliance) {
    43.       super( patternAlliance );
    44.   }
    46.   @Override
    47.   public String getName() {
    48.       return "中介者神阁";
    49.   }
    50. }
    53. package com.md.tertium;
    55. public class CommandSchool extends School {
    56.   public CommandSchool(IPatternAlliance patternAlliance) {
    57.       super( patternAlliance );
    58.   }
    60.   @Override
    61.   public String getName() {
    62.       return "命令门";
    63.   }
    64. }
    65. package com.md.tertium;
    67. public class SingletonSchool extends School {
    68.   public SingletonSchool(IPatternAlliance patternAlliance) {
    69.       super( patternAlliance );
    70.   }
    72.   @Override
    73.   public String getName() {
    74.       return "单例宗";
    75.   }
    76. }
    77. package com.md.tertium;
    79. public class StrategySchool extends School {
    80.   public StrategySchool(IPatternAlliance patternAlliance) {
    81.       super( patternAlliance );
    82.   }
    84.   @Override
    85.   public String getName() {
    86.       return "策略";
    87.   }
    89. }
    90. package com.md.tertium;
    92. import java.util.List;
    94. //模式联盟 中介者接口
    95. public interface IPatternAlliance {
    96.   //提供一个加入联盟的接口
    97.   public abstract void add(School school);
    99.   //防御联盟
    100.   public abstract void resolveAttack(School activeSide, School passiveSide);
    102.   //攻击联盟
    103.   public abstract void attack(School passiveSide);
    104. }
    105. package com.md.tertium;
    107. import java.util.LinkedList;
    108. import java.util.List;
    110. //联盟模式的具体实现
    111. public class PatternAlliance implements IPatternAlliance {
    113.   private List <School> schoolList = new LinkedList <School>();
    115.   @Override
    116.   public void add(School school) {
    117.       //加入联盟
    118.       schoolList.add( school );
    119.   }
    121.   @Override
    122.   public void resolveAttack(School activeSide, School passiveSide) {
    123.       if (schoolList.contains( passiveSide )) {
    124.           System.out.println( "被攻方" + passiveSide.getName() + "已加入联盟，联盟将齐力防御！" );
    125.           for (School school : schoolList) {
    126.               school.defense();
    127.           }
    128.       } else {
    129.           System.out.println( "被攻方" + passiveSide.getName() + "未加入联盟，联盟不给予防御帮助！" );
    130.           passiveSide.defense();
    131.       }
    132.   }
    134.   @Override
    135.   public void attack(School passiveSide) {
    136.       if (schoolList.contains( passiveSide ) && schoolList.contains( passiveSide )) {
    137.           System.out.println( "主攻方" + passiveSide.getName() + "以及被攻方" + passiveSide.getName() + "都已加入联盟，不允许内讧！" );
    138.       } else if (schoolList.contains( passiveSide ) && !schoolList.contains( passiveSide )) {
    139.           System.out.println( "主攻方" + passiveSide.getName() + "已加入联盟，被攻方" + passiveSide.getName() + "不在联盟之中，将集体攻打该门派！" );
    140.           for (School school : schoolList) {
    141.               school.attack( passiveSide );
    142.           }
    143.       } else {
    144.           System.out.println( "主攻方" + passiveSide.getName() + "未加入联盟，联盟无权干预此事！" );
    145.           passiveSide.attack( passiveSide );
    146.       }
    147.   }
    148. }
    149. package com.md.tertium;
    151. public class Main {
    152.   public static void main(String[] args) {
    153. //        School singletonSchool = new SingletonSchool();
    154. //        School commandSchool = new CommandSchool();
    155. //        School mediatorSchool = new MediatorSchool();
    156. //
    157. //        singletonSchool.attack( mediatorSchool );
    158. //        commandSchool.attack( mediatorSchool );
    159. //
    160. //        mediatorSchool.defense();
    161.       IPatternAlliance patternAlliance = new PatternAlliance();
    163.       School singletonSchool = new SingletonSchool( patternAlliance );
    164.       School commandSchool = new CommandSchool( patternAlliance );
    165.       School mediatorSchool = new MediatorSchool( patternAlliance );
    167.       School strategySchool = new StrategySchool( patternAlliance );
    169.       //策略宫没有被联盟收留
    170.       patternAlliance.add( mediatorSchool );
    171.       patternAlliance.add( commandSchool );
    172.       patternAlliance.add( singletonSchool );
    174.       singletonSchool.attackByPatternAlliance( mediatorSchool );
    175.       commandSchool.attackByPatternAlliance( mediatorSchool );
    176.       System.out.println( "------------------------------------------------------" );
    177.       mediatorSchool.attackByPatternAlliance( strategySchool );
    178.       System.out.println( "------------------------------------------------------" );
    179.       strategySchool.attackByPatternAlliance( mediatorSchool );
    180.       mediatorSchool.defenseByPatternAlliance();
    181.       System.out.println( "------------------------------------------------------" );
    182.   }
    183. }

    《中介者模式》针对的问题是，解决一系列对象之间复杂的耦合关系，这一系列对象往往是“多对多”的耦合关系，《中介者模式》采用一个中介者对象将这一系列对象集中管理，而各个对象也将自己与其它对象的交互行为委托给中介者处理，从而减少这一系列对象之间的耦合。
    它的优点倒是非常明显，清除了一系列对象之间复杂的耦合关系，并且中介者可以控制这一系列对象的行为，统一管理。
    《中介者模式》的缺点是，由于中介者负责着一系列对象的交互与控制，所以中介者的类会非常复杂，而且一旦中介者类无法正常工作，那么所有将行为委托给中介者的类都将会出现问题，所以在使用的时候还是要特别小心。