用一个中介者对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使耦合松散，而且可以独立地改变它们之间的交互。

    【角色】

    • 抽象中介者（Mediator）：它是中介者的接口，提供了客户对象注册与转发客户对象信息的抽象方法。
    • 具体中介者（ConcreteMediator）：实现中介者接口，定义一个List来管理客户对象，协调各个客户角色之间的交互关系，因此它依赖于客户角色。
    • 抽象客户类（Customer）：定义客户类的接口，保存中介者对象，提供客户对象交互的抽象方法。
    • 具体客户类（ConcreteCustomer）：是抽象客户类的实现者，当需要与其他客户对象交互时，由中介者对象负责后续的交互。

    【优点】

    • 降低了对象之间的耦合性，使得对象易于独立地被复用。
    • 将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

    【缺点】

    • 中介者会膨胀的很大，而且逻辑复杂。

      1. /**
      2. * 中介者
      3. */
      4. public interface Mediator {
      5.   /**
      6.    * 添加客户
      7.    * @param customer
      8.    */
      9.   void addCustomer(Customer customer);
      11.   /**
      12.    * 转发消息
      13.    * @param message
      14.    * @param customer
      15.    */
      16.   void forward(String message, Customer customer);
      17. }
      1. /**
      2. * 具体中介者
      3. */
      4. public class ConcreteMediator implements Mediator {
      6.   private List<Customer> customerList = new ArrayList<>();
      8.   /**
      9.    * 添加客户
      10.    */
      11.   @Override
      12.   public void addCustomer(Customer customer) {
      13.       customerList.add(customer);
      14.   }
      16.   /**
      17.    * 转发消息
      18.    */
      19.   @Override
      20.   public void forward(String message, Customer customer) {
      21.       for (Customer c : customerList) {
      22.           // 如果是买方发布消息，则通知所有卖方
      23.           if (customer instanceof Buyer) {
      24.               if (c instanceof Seller) {
      25.                   c.answer(message);
      26.               }
      27.           // 如果是卖方发布消息，则通知所有买方
      28.           } else {
      29.               if (c instanceof Buyer) {
      30.                   c.answer(message);
      31.               }
      32.           }
      33.       }
      34.   }
      35. }
      1. /**
      2. * 客户抽象类
      3. */
      4. public abstract class Customer {
      5.   // 客户名称
      6.   protected String name;
      7.   // 中介
      8.   protected Mediator mediator;
      10.   public Customer(String name, Mediator mediator) {
      11.       this.name = name;
      12.       this.mediator = mediator;
      13.   }
      15.   /**
      16.    * 客户的需求
      17.    */
      18.   public void need(String message) {
      19.       System.out.println(name + ": " + message);
      20.       // 交给中介转发
      21.       mediator.forward(message, this);
      22.   }
      24.   /**
      25.    * 收到回复
      26.    */
      27.   public abstract void answer(String message);
      28. }
      1. /**
      2. * 买方（买房者)
      3. */
      4. public class Buyer extends Customer {
      6.   public Buyer(String name, Mediator mediator) {
      7.       super(name, mediator);
      8.   }
      10.   @Override
      11.   public void answer(String message) {
      12.       System.out.println("（买方）" + name + "收到消息：" + message);
      13.   }
      14. }
      1. /**
      2. * 房东（卖房者)
      3. */
      4. public class Seller extends Customer {
      6.   public Seller(String name, Mediator mediator) {
      7.       super(name, mediator);
      8.   }
      10.   @Override
      11.   public void answer(String message) {
      12.       System.out.println("（房东）" + name + "收到消息：" + message);
      13.   }
      14. }

      ```java public class MediatorTest { public static void main(String[] args) {

      1.   // 中介者
      2.   ConcreteMediator mediator = new ConcreteMediator();
      4.   // 买方
      5.   Buyer buyer1 = new Buyer("张三", mediator);
      6.   Buyer buyer2 = new Buyer("李四", mediator);
      8.   // 房东
      9.   Seller seller1 = new Seller("老王", mediator);
      10.   Seller seller2 = new Seller("老李", mediator);
      12.   // 添加客户
      13.   mediator.addCustomer(buyer1);
      14.   mediator.addCustomer(buyer2);
      15.   mediator.addCustomer(seller1);
      16.   mediator.addCustomer(seller2);
      18.   buyer1.need("我想买一个总价200w的房子");
      20.   System.out.println();
      22.   seller2.need("我打算出售一个三室一厅的房子");

      } } ——输出—— 张三: 我想买一个总价200w的房子 （房东）老王收到消息：我想买一个总价200w的房子 （房东）老李收到消息：我想买一个总价200w的房子

    老李: 我打算出售一个三室一厅的房子 （买方）张三收到消息：我打算出售一个三室一厅的房子 （买方）李四收到消息：我打算出售一个三室一厅的房子 ```