Java中介者模式核心思想，分点阐述

Java中介者模式是一种行为设计模式，其核心思想在于将系统的各个对象之间的通信解耦，使得它们只需要相互传递消息而不是直接交互。以下是该模式的几个关键点：

1. **定义**：中介者是一个独立的对象，它负责在各个对象之间传达请求，并处理它们之间的依赖关系。其他对象与中介者通信，而不是直接相互作用。

2. **角色**：
- **参与者（ Participants）**：系统中的各个实体，它们需要进行交互但不想相互耦合。
- **中介者（ Mediator）**：封装了所有参与者的行为并提供了一个统一的接口让参与者发送请求。

3. **优点**：
- 提高了系统的可维护性和灵活性，因为修改中介者的行为不会影响到具体的参与者。
- 可以降低系统的耦合度，使得各部分可以独立改变而无需更新其它部分。

4. **应用场景**：当系统中的对象太多，或者对象之间有多对多的关系时，采用中介者模式可以简化复杂性，比如事件驱动的系统或者大型游戏中的控制中心等。

5. **注意事项**：
- 中介者模式可能导致额外的消息传递开销，如果滥用，可能会增加系统的运行时间和内存消耗。
- 设计合理的接口和类结构至关重要，过少或过多的中介者都可能导致模式失效。

相关问题

java 中介者模式 例子

一个简单的 Java 中介者模式的例子是一个聊天室程序。在这个程序中，每个用户都是一个 Colleague 对象，而聊天室则是一个 Mediator 对象。当一个用户发送消息时，它会通过 Mediator 对象来发送消息给其他用户。这样，每个用户都不需要知道其他用户的存在，而只需要与 Mediator 对象进行通信即可。

以下是一个简单的 Java 中介者模式的代码示例：

// Colleague 接口
interface Colleague {
    void sendMessage(String message);
    void receiveMessage(String message);
}

// Mediator 接口
interface Mediator {
    void addUser(Colleague user);
    void sendMessage(Colleague sender, String message);
}

// ChatRoom 类实现了 Mediator 接口
class ChatRoom implements Mediator {
    private List<Colleague> users = new ArrayList<>();

    @Override
    public void addUser(Colleague user) {
        users.add(user);
    }

    @Override
    public void sendMessage(Colleague sender, String message) {
        for (Colleague user : users) {
            if (user != sender) {
                user.receiveMessage(message);
            }
        }
    }
}

// User 类实现了 Colleague 接口
class User implements Colleague {
    private String name;
    private Mediator mediator;

    public User(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }

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

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

// 使用示例
public class Main {
    public static void main(String[] args) {
        Mediator chatRoom = new ChatRoom();

        Colleague user1 = new User("Alice", chatRoom);
        Colleague user2 = new User("Bob", chatRoom);
        Colleague user3 = new User("Charlie", chatRoom);

        chatRoom.addUser(user1);
        chatRoom.addUser(user2);
        chatRoom.addUser(user3);

        user1.sendMessage("Hello, everyone!");
    }
}

在这个例子中，我们创建了一个 ChatRoom 对象作为 Mediator，然后创建了三个 User 对象作为 Colleague，并将它们添加到 ChatRoom 中。当 user1 发送消息时，它会通过 ChatRoom 对象来发送消息给其他用户。其他用户会收到消息并输出到控制台上。

中介者模式实例java

中介者模式（Mediator Pattern）是一种行为型设计模式，它允许将对象间的通信封装到一个中介对象中，从而使得对象间不再直接相互引用，降低了对象间的耦合度。

下面是一个简单的中介者模式实例，我们假设有三个类：用户（User）、聊天室（ChatRoom）和中介者（ChatMediator）。其中，用户类包含了用户的姓名和中介者实例，聊天室类包含了聊天室名称和中介者实例，中介者类包含了用户列表和聊天室实例，以及处理用户间通信的方法。

User.java

public class User {
    private String name;
    private ChatMediator chatMediator;
 
    public User(String name, ChatMediator chatMediator) {
        this.name = name;
        this.chatMediator = chatMediator;
    }
 
    public String getName() {
        return name;
    }
 
    public void sendMessage(String message) {
        chatMediator.sendMessage(message, this);
    }
 
    public void receiveMessage(String message) {
        System.out.println(name + " received message: " + message);
    }
}

ChatRoom.java

public class ChatRoom {
    private String name;
    private ChatMediator chatMediator;
 
    public ChatRoom(String name, ChatMediator chatMediator) {
        this.name = name;
        this.chatMediator = chatMediator;
    }
 
    public String getName() {
        return name;
    }
 
    public void sendMessage(String message, User user) {
        chatMediator.sendMessage(message, user);
    }
}

ChatMediator.java

import java.util.ArrayList;
import java.util.List;
 
public class ChatMediator {
    private List<User> users;
    private ChatRoom chatRoom;
 
    public ChatMediator(ChatRoom chatRoom) {
        this.chatRoom = chatRoom;
        this.users = new ArrayList<>();
    }
 
    public void addUser(User user) {
        users.add(user);
    }
 
    public void sendMessage(String message, User user) {
        for (User u : users) {
            if (u != user) {
                u.receiveMessage(message);
            }
        }
    }
}

使用中介者模式，我们可以创建多个用户和聊天室，并将它们注册到中介者中，从而实现用户间的通信。

Main.java

public class Main {
    public static void main(String[] args) {
        ChatRoom chatRoom = new ChatRoom("Java Chat Room", new ChatMediator());
        User user1 = new User("Alice", chatMediator);
        User user2 = new User("Bob", chatMediator);
        User user3 = new User("Charlie", chatMediator);
        chatRoom.addUser(user1);
        chatRoom.addUser(user2);
        chatRoom.addUser(user3);
        user1.sendMessage("Hello, everyone!");
    }
}

输出结果：

Bob received message: Hello, everyone!
Charlie received message: Hello, everyone!