设计模式之中介者模式

        中介者模式是一种行为型设计模式，用于减少对象之间的直接通信，从而降低系统的耦合性。中介者模式通过引入一个中介者对象，集中处理对象之间的交互，使对象之间不需要直接相互引用，而是通过中介者进行通信。

中介者模式的主要目标是促进对象之间的松耦合，从而提高系统的可维护性和可扩展性。这种模式适用于场景中有多个对象之间需要协同工作，但是对象之间不应该直接相互通信的情况。

中介者模式的关键要素包括：

1. 中介者（Mediator）： 定义一个接口或抽象类，用于声明中介者对象的方法。中介者通常包含了一些用于处理对象之间通信的方法，如消息的广播或转发。

2. 具体中介者（Concrete Mediator）： 实现了中介者接口，负责实际处理对象之间的通信。它维护了一个对象列表，用于跟踪和管理参与通信的对象。

3. 同事类（Colleague）： 表示系统中的各个具体对象，这些对象之间需要进行通信。每个同事类都包含一个对中介者对象的引用，通过中介者来进行通信。

中介者模式的优点包括：

• 降低耦合度： 中介者模式可以将对象之间的直接依赖关系降低到最低，使得系统更加松耦合，减少了对象之间的相互依赖。
• 简化对象之间的通信： 中介者模式将对象之间的通信集中管理，使得通信逻辑更加清晰和集中。
• 提高可维护性： 中介者模式使得系统的维护和扩展更加容易，因为对象之间的关系都由中介者管理。
• 促进重用： 中介者模式可以使中介者对象在不同的场景中重用，从而提高了代码的重用性。

下面是一个简单的中介者模式示例：

// 中介者接口
interface Mediator {
    void sendMessage(String message, Colleague colleague);
}

// 具体中介者
class ConcreteMediator implements Mediator {
    private Colleague colleague1;
    private Colleague colleague2;

    public void setColleague1(Colleague colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(Colleague colleague2) {
        this.colleague2 = colleague2;
    }

    public void sendMessage(String message, Colleague colleague) {
        if (colleague == colleague1) {
            colleague2.receiveMessage(message);
        } else if (colleague == colleague2) {
            colleague1.receiveMessage(message);
        }
    }
}

// 同事类
abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void sendMessage(String message);
    public abstract void receiveMessage(String message);
}

class ConcreteColleague1 extends Colleague {
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    public void sendMessage(String message) {
        mediator.sendMessage(message, this);
    }

    public void receiveMessage(String message) {
        System.out.println("Colleague1 received: " + message);
    }
}

class ConcreteColleague2 extends Colleague {
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    public void sendMessage(String message) {
        mediator.sendMessage(message, this);
    }

    public void receiveMessage(String message) {
        System.out.println("Colleague2 received: " + message);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();

        ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
        ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);

        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);

        colleague1.sendMessage("Hello, Colleague2!");
        colleague2.sendMessage("Hi, Colleague1!");
    }
}

运行结果：

        在上述示例中，我们有一个中介者接口Mediator，以及一个具体中介者ConcreteMediator。同时，我们有两个同事类ConcreteColleague1和ConcreteColleague2，它们之间通过中介者进行通信。

        在客户端代码中，我们创建了中介者对象和两个同事对象，并将同事对象注册到中介者中。然后，同事对象可以通过中介者发送消息，并且中介者会将消息传递给适当的同事对象。这种方式实现了对象之间的松耦合，使得同事对象不需要直接引用其他同事对象，而是通过中介者进行通信。