概念

        中介者设计模式是一种行为型设计模式，它通过引入一个中介对象来封装一组对象之间的交互，使得对象之间不需要显式地相互引用，从而降低它们之间的耦合。通过将对象间的通信封装到中介者对象中，可以更容易地对这些对象的交互进行维护和修改。

组成角色

1. 抽象中介者（Mediator）：定义了一个接口，用于与各同事（Colleague）对象之间的通信。
2. 具体中介者（ConcreteMediator）：实现抽象中介者接口，协调各同事对象的交互关系。它需要了解并维护各同事对象。
3. 抽象同事（Colleague）：定义各个同事对象的接口。各同事对象应该知道中介者对象，即可以与中介者对象通信。同事对象与其他同事对象的通信都通过中介者来完成。
4. 具体同事（ConcreteColleague）：实现抽象同事接口，具体的同事对象。每个具体同事对象只需要知道自己与中介者的交互，不需要了解其他同事。

相关图示

示例代码

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

// 具体中介者
class ConcreteMediator implements Mediator {
    
    
    private ColleagueA colleagueA;
    private ColleagueB colleagueB;

    public void setColleagueA(ColleagueA colleagueA) {
    
    
        this.colleagueA = colleagueA;
    }

    public void setColleagueB(ColleagueB colleagueB) {
    
    
        this.colleagueB = colleagueB;
    }

    @Override
    public void sendMessage(String message, Colleague colleague) {
    
    
        if (colleague == colleagueA) {
    
    
            colleagueB.receiveMessage(message);
        } else {
    
    
            colleagueA.receiveMessage(message);
        }
    }
}

// 抽象同事
abstract class Colleague {
    
    
    protected Mediator mediator;

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

// 具体同事A
class ColleagueA extends Colleague {
    
    
    public ColleagueA(Mediator mediator) {
    
    
        super(mediator);
    }

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

    public void receiveMessage(String message) {
    
    
        System.out.println("同事A收到信息：" + message);
    }
}

// 具体同事B
class ColleagueB extends Colleague {
    
    
    public ColleagueB(Mediator mediator) {
    
    
        super(mediator);
    }

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

    public void receiveMessage(String message) {
    
    
        System.out.println("同事B收到信息：" + message);
    }
}

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

        ColleagueA colleagueA = new ColleagueA(mediator);
        ColleagueB colleagueB = new ColleagueB(mediator);

        mediator.setColleagueA(colleagueA);
        mediator.setColleagueB(colleagueB);

        colleagueA.send("你好，同事B！");
        colleagueB.send("你好，同事A！");
    }
}

适用场景

1. 大量对象交互：在一个系统中，有许多对象需要相互交流和协作。通过引入中介者，可以将复杂的对象关系简化，减少直接依赖。
2. 易扩展：当需要添加新的对象时，无需修改原有对象之间的交互逻辑，只需在中介者中添加新对象的交互逻辑，降低了维护成本。
3. 解耦：中介者将对象之间的交互行为封装起来，使得各对象之间的耦合度降低，有利于代码重用和模块化。
4. 需要改变对象交互方式：当需要改变对象之间的交互方式时，无需修改对象本身，只需修改中介者，这有助于提高系统的灵活性。

以下是一些中介者设计模式可能适用的实际场景：

1. 聊天室应用：聊天室中的用户通过中介者对象（聊天室服务器）发送和接收消息，而无需直接与其他用户通信。
2. 交通信号控制系统：多个交通信号灯通过中介者（信号控制器）进行协调，避免直接引用和相互影响。
3. 用户界面(UI)组件协调：在复杂的用户界面中，多个UI组件之间的交互和状态变化可以通过中介者对象进行统一管理，降低组件之间的耦合程度。
4. 机场调度系统：通过中介者（调度中心）来协调飞机、跑道、航班等资源的调度，降低各部分之间的依赖。

在多个对象之间需要进行协调、交互或者依赖的场景下，可以考虑使用中介者设计模式。