设计模式入门教程20：中介者模式 - 让对象间交互更简洁

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

// 抽象中介者
abstract class Mediator {
    public abstract void notify(Component sender, String event);
}

// 抽象组件
abstract class Component {
    protected Mediator mediator;

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

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }
}

// 具体中介者
class ConcreteMediator extends Mediator {
    private ComponentA componentA;
    private ComponentB componentB;

    public void setComponents(ComponentA a, ComponentB b) {
        this.componentA = a;
        this.componentB = b;
    }

    @Override
    public void notify(Component sender, String event) {
        if (sender == componentA) {
            if ("EventA".equals(event)) {
                componentB.operationB();
            }
        } else if (sender == componentB) {
            if ("EventB".equals(event)) {
                componentA.operationA();
            }
        }
    }
}

// 具体组件
class ComponentA extends Component {
    public ComponentA(Mediator mediator) {
        super(mediator);
    }

    public void operationA() {
        System.out.println("执行操作A");
        mediator.notify(this, "EventA");
    }
}

class ComponentB extends Component {
    public ComponentB(Mediator mediator) {
        super(mediator);
    }

    public void operationB() {
        System.out.println("执行操作B");
        mediator.notify(this, "EventB");
    }
}

1
2
3
4
5
6

// 智能家居中介者接口
interface SmartHomeMediator {
    void notify(SmartDevice sender, String event, Object data);
    void registerDevice(SmartDevice device);
    void removeDevice(SmartDevice device);
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210

// 智能家居控制中心
class SmartHomeControlCenter implements SmartHomeMediator {
    private List<SmartDevice> devices = new ArrayList<>();
    private Map<String, Object> environmentData = new HashMap<>();
    private boolean securityMode = false;
    private boolean energySavingMode = false;

    @Override
    public void registerDevice(SmartDevice device) {
        devices.add(device);
        device.setMediator(this);
        System.out.println("设备已注册：" + device.getName());
    }

    @Override
    public void removeDevice(SmartDevice device) {
        devices.remove(device);
        System.out.println("设备已移除：" + device.getName());
    }

    @Override
    public void notify(SmartDevice sender, String event, Object data) {
        System.out.println("收到事件：" + sender.getName() + " -> " + event);

        switch (event) {
            case "MOTION_DETECTED":
                handleMotionDetected(sender, data);
                break;
            case "TEMPERATURE_CHANGED":
                handleTemperatureChanged(sender, data);
                break;
            case "DOOR_OPENED":
                handleDoorOpened(sender, data);
                break;
            case "DOOR_CLOSED":
                handleDoorClosed(sender, data);
                break;
            case "LIGHT_TURNED_ON":
                handleLightTurnedOn(sender, data);
                break;
            case "LIGHT_TURNED_OFF":
                handleLightTurnedOff(sender, data);
                break;
            case "SECURITY_ARMED":
                handleSecurityArmed(sender, data);
                break;
            case "SECURITY_DISARMED":
                handleSecurityDisarmed(sender, data);
                break;
            default:
                System.out.println("未知事件：" + event);
        }
    }

    private void handleMotionDetected(SmartDevice sender, Object data) {
        String location = (String) data;
        environmentData.put("lastMotionLocation", location);

        // 如果是夜间，自动开灯
        if (isNightTime()) {
            getDevicesByType("SmartLight")
                .stream()
                .filter(device -> device.getName().contains(location))
                .forEach(light -> ((SmartLight) light).turnOn());
        }

        // 如果启用了安全模式，触发警报
        if (securityMode) {
            getDevicesByType("SecurityCamera")
                .forEach(camera -> ((SecurityCamera) camera).startRecording());

            getDevicesByType("AlarmSystem")
                .forEach(alarm -> ((AlarmSystem) alarm).triggerAlarm());
        }
    }

    private void handleTemperatureChanged(SmartDevice sender, Object data) {
        double temperature = (Double) data;
        environmentData.put("currentTemperature", temperature);

        // 自动调节空调
        if (temperature > 26.0) {
            getDevicesByType("AirConditioner")
                .forEach(ac -> ((AirConditioner) ac).setCooling(22.0));
        } else if (temperature < 18.0) {
            getDevicesByType("AirConditioner")
                .forEach(ac -> ((AirConditioner) ac).setHeating(22.0));
        }

        // 节能模式下调整设备
        if (energySavingMode && temperature > 24.0) {
            getDevicesByType("SmartLight")
                .forEach(light -> ((SmartLight) light).dimTo(50));
        }
    }

    private void handleDoorOpened(SmartDevice sender, Object data) {
        // 门开启时的联动
        if (securityMode) {
            // 安全模式下记录开门事件
            System.out.println("安全警告：门被打开 - " + sender.getName());
        } else {
            // 正常模式下开启入口灯光
            getDevicesByType("SmartLight")
                .stream()
                .filter(light -> light.getName().contains("entrance"))
                .forEach(light -> ((SmartLight) light).turnOn());
        }
    }

    private void handleDoorClosed(SmartDevice sender, Object data) {
        // 所有门关闭时，可以启用节能模式
        boolean allDoorsClosed = getDevicesByType("SmartDoor")
                .stream()
                .allMatch(door -> !((SmartDoor) door).isOpen());

        if (allDoorsClosed && !hasRecentMotion()) {
            enableEnergySavingMode();
        }
    }

    private void handleLightTurnedOn(SmartDevice sender, Object data) {
        // 灯光开启时的联动（如果不是自动开启的话）
        if (!energySavingMode) {
            // 可以调整其他相关设备
        }
    }

    private void handleLightTurnedOff(SmartDevice sender, Object data) {
        // 检查是否所有灯都关闭，进入深度节能模式
        boolean allLightsOff = getDevicesByType("SmartLight")
                .stream()
                .noneMatch(light -> ((SmartLight) light).isOn());

        if (allLightsOff) {
            enableDeepEnergySavingMode();
        }
    }

    private void handleSecurityArmed(SmartDevice sender, Object data) {
        securityMode = true;
        System.out.println("安全模式已启用");

        // 关闭所有非必要设备
        getDevicesByType("SmartLight")
                .forEach(light -> ((SmartLight) light).turnOff());

        // 启动所有安全设备
        getDevicesByType("SecurityCamera")
                .forEach(camera -> ((SecurityCamera) camera).startMonitoring());
    }

    private void handleSecurityDisarmed(SmartDevice sender, Object data) {
        securityMode = false;
        System.out.println("安全模式已关闭");

        // 停止录制
        getDevicesByType("SecurityCamera")
                .forEach(camera -> ((SecurityCamera) camera).stopRecording());
    }

    // 辅助方法
    private List<SmartDevice> getDevicesByType(String type) {
        return devices.stream()
                .filter(device -> device.getClass().getSimpleName().equals(type))
                .collect(Collectors.toList());
    }

    private boolean isNightTime() {
        // 简化实现：假设22:00-06:00为夜间
        int hour = LocalDateTime.now().getHour();
        return hour >= 22 || hour <= 6;
    }

    private boolean hasRecentMotion() {
        // 检查最近5分钟是否有移动
        return environmentData.containsKey("lastMotionTime") &&
               System.currentTimeMillis() - (Long) environmentData.get("lastMotionTime") < 300000;
    }

    private void enableEnergySavingMode() {
        energySavingMode = true;
        System.out.println("已启用节能模式");

        // 调暗所有灯光
        getDevicesByType("SmartLight")
                .forEach(light -> ((SmartLight) light).dimTo(30));

        // 调整空调温度
        getDevicesByType("AirConditioner")
                .forEach(ac -> ((AirConditioner) ac).setEcoMode(true));
    }

    private void enableDeepEnergySavingMode() {
        System.out.println("已启用深度节能模式");

        // 关闭非必要设备
        getDevicesByType("AirConditioner")
                .forEach(ac -> ((AirConditioner) ac).turnOff());
    }

    public void showSystemStatus() {
        System.out.println("=== 智能家居系统状态 ===");
        System.out.println("安全模式：" + (securityMode ? "启用" : "关闭"));
        System.out.println("节能模式：" + (energySavingMode ? "启用" : "关闭"));
        System.out.println("注册设备数：" + devices.size());
        System.out.println("环境数据：" + environmentData);
        System.out.println("========================");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// 智能设备抽象类
abstract class SmartDevice {
    protected String name;
    protected SmartHomeMediator mediator;
    protected boolean isOnline;

    public SmartDevice(String name) {
        this.name = name;
        this.isOnline = true;
    }

    public void setMediator(SmartHomeMediator mediator) {
        this.mediator = mediator;
    }

    public String getName() {
        return name;
    }

    public boolean isOnline() {
        return isOnline;
    }

    public void setOnline(boolean online) {
        this.isOnline = online;
        if (mediator != null) {
            mediator.notify(this, online ? "DEVICE_ONLINE" : "DEVICE_OFFLINE", null);
        }
    }

    protected void notifyMediator(String event, Object data) {
        if (mediator != null && isOnline) {
            mediator.notify(this, event, data);
        }
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318

// 智能灯具
class SmartLight extends SmartDevice {
    private boolean isOn;
    private int brightness; // 0-100

    public SmartLight(String name) {
        super(name);
        this.isOn = false;
        this.brightness = 100;
    }

    public void turnOn() {
        if (!isOn) {
            isOn = true;
            System.out.println(name + " 灯光已开启");
            notifyMediator("LIGHT_TURNED_ON", null);
        }
    }

    public void turnOff() {
        if (isOn) {
            isOn = false;
            System.out.println(name + " 灯光已关闭");
            notifyMediator("LIGHT_TURNED_OFF", null);
        }
    }

    public void dimTo(int percentage) {
        if (isOn) {
            this.brightness = Math.max(0, Math.min(100, percentage));
            System.out.println(name + " 亮度调节至：" + brightness + "%");
            notifyMediator("LIGHT_DIMMED", brightness);
        }
    }

    public boolean isOn() {
        return isOn;
    }

    public int getBrightness() {
        return brightness;
    }
}

// 智能门锁
class SmartDoor extends SmartDevice {
    private boolean isOpen;
    private boolean isLocked;

    public SmartDoor(String name) {
        super(name);
        this.isOpen = false;
        this.isLocked = true;
    }

    public void open() {
        if (!isOpen && !isLocked) {
            isOpen = true;
            System.out.println(name + " 门已打开");
            notifyMediator("DOOR_OPENED", null);
        } else if (isLocked) {
            System.out.println(name + " 门被锁定，无法打开");
        }
    }

    public void close() {
        if (isOpen) {
            isOpen = false;
            System.out.println(name + " 门已关闭");
            notifyMediator("DOOR_CLOSED", null);
        }
    }

    public void lock() {
        if (!isLocked) {
            isLocked = true;
            if (isOpen) {
                close();
            }
            System.out.println(name + " 门已锁定");
            notifyMediator("DOOR_LOCKED", null);
        }
    }

    public void unlock() {
        if (isLocked) {
            isLocked = false;
            System.out.println(name + " 门已解锁");
            notifyMediator("DOOR_UNLOCKED", null);
        }
    }

    public boolean isOpen() {
        return isOpen;
    }

    public boolean isLocked() {
        return isLocked;
    }
}

// 温度传感器
class TemperatureSensor extends SmartDevice {
    private double currentTemperature;

    public TemperatureSensor(String name) {
        super(name);
        this.currentTemperature = 22.0; // 默认室温
    }

    public void updateTemperature(double temperature) {
        this.currentTemperature = temperature;
        System.out.println(name + " 检测到温度：" + temperature + "°C");
        notifyMediator("TEMPERATURE_CHANGED", temperature);
    }

    public double getCurrentTemperature() {
        return currentTemperature;
    }

    // 模拟温度变化
    public void simulateTemperatureChange() {
        // 随机温度变化
        double change = (Math.random() - 0.5) * 4; // -2°C 到 +2°C
        updateTemperature(currentTemperature + change);
    }
}

// 移动传感器
class MotionSensor extends SmartDevice {
    private boolean motionDetected;

    public MotionSensor(String name) {
        super(name);
        this.motionDetected = false;
    }

    public void detectMotion(String location) {
        motionDetected = true;
        System.out.println(name + " 检测到移动：" + location);
        notifyMediator("MOTION_DETECTED", location);

        // 模拟移动检测持续一段时间
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                motionDetected = false;
                System.out.println(name + " 移动检测结束");
            }
        }, 5000); // 5秒后结束移动检测
    }

    public boolean isMotionDetected() {
        return motionDetected;
    }
}

// 空调设备
class AirConditioner extends SmartDevice {
    private boolean isOn;
    private double targetTemperature;
    private String mode; // "cooling", "heating", "off"
    private boolean ecoMode;

    public AirConditioner(String name) {
        super(name);
        this.isOn = false;
        this.targetTemperature = 22.0;
        this.mode = "off";
        this.ecoMode = false;
    }

    public void turnOn() {
        isOn = true;
        mode = "cooling";
        System.out.println(name + " 空调已开启（制冷模式）");
        notifyMediator("AC_TURNED_ON", mode);
    }

    public void turnOff() {
        isOn = false;
        mode = "off";
        System.out.println(name + " 空调已关闭");
        notifyMediator("AC_TURNED_OFF", null);
    }

    public void setCooling(double temperature) {
        isOn = true;
        mode = "cooling";
        targetTemperature = temperature;
        System.out.println(name + " 设置制冷温度：" + temperature + "°C");
        notifyMediator("AC_MODE_CHANGED", "cooling");
    }

    public void setHeating(double temperature) {
        isOn = true;
        mode = "heating";
        targetTemperature = temperature;
        System.out.println(name + " 设置制热温度：" + temperature + "°C");
        notifyMediator("AC_MODE_CHANGED", "heating");
    }

    public void setEcoMode(boolean eco) {
        this.ecoMode = eco;
        if (eco) {
            targetTemperature += mode.equals("cooling") ? 2 : -2; // 节能调整
        }
        System.out.println(name + " 节能模式：" + (eco ? "启用" : "关闭"));
        notifyMediator("AC_ECO_MODE_CHANGED", eco);
    }

    public boolean isOn() { return isOn; }
    public double getTargetTemperature() { return targetTemperature; }
    public String getMode() { return mode; }
    public boolean isEcoMode() { return ecoMode; }
}

// 安全摄像头
class SecurityCamera extends SmartDevice {
    private boolean isRecording;
    private boolean isMonitoring;

    public SecurityCamera(String name) {
        super(name);
        this.isRecording = false;
        this.isMonitoring = false;
    }

    public void startMonitoring() {
        isMonitoring = true;
        System.out.println(name + " 开始监控");
        notifyMediator("CAMERA_MONITORING_STARTED", null);
    }

    public void stopMonitoring() {
        isMonitoring = false;
        if (isRecording) {
            stopRecording();
        }
        System.out.println(name + " 停止监控");
        notifyMediator("CAMERA_MONITORING_STOPPED", null);
    }

    public void startRecording() {
        if (isMonitoring) {
            isRecording = true;
            System.out.println(name + " 开始录制");
            notifyMediator("CAMERA_RECORDING_STARTED", null);
        }
    }

    public void stopRecording() {
        if (isRecording) {
            isRecording = false;
            System.out.println(name + " 停止录制");
            notifyMediator("CAMERA_RECORDING_STOPPED", null);
        }
    }

    public boolean isRecording() { return isRecording; }
    public boolean isMonitoring() { return isMonitoring; }
}

// 警报系统
class AlarmSystem extends SmartDevice {
    private boolean isArmed;
    private boolean isAlarming;

    public AlarmSystem(String name) {
        super(name);
        this.isArmed = false;
        this.isAlarming = false;
    }

    public void arm() {
        isArmed = true;
        System.out.println(name + " 警报系统已启用");
        notifyMediator("SECURITY_ARMED", null);
    }

    public void disarm() {
        isArmed = false;
        if (isAlarming) {
            stopAlarm();
        }
        System.out.println(name + " 警报系统已关闭");
        notifyMediator("SECURITY_DISARMED", null);
    }

    public void triggerAlarm() {
        if (isArmed && !isAlarming) {
            isAlarming = true;
            System.out.println(name + " 🚨 警报响起！");
            notifyMediator("ALARM_TRIGGERED", null);

            // 模拟警报持续30秒
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    stopAlarm();
                }
            }, 30000);
        }
    }

    public void stopAlarm() {
        if (isAlarming) {
            isAlarming = false;
            System.out.println(name + " 警报已停止");
            notifyMediator("ALARM_STOPPED", null);
        }
    }

    public boolean isArmed() { return isArmed; }
    public boolean isAlarming() { return isAlarming; }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271

// 聊天室中介者接口
interface ChatRoomMediator {
    void sendMessage(String message, User user);
    void addUser(User user);
    void removeUser(User user);
    void notifyUsers(String message, User excludeUser);
}

// 聊天室实现
class ChatRoom implements ChatRoomMediator {
    private List<User> users = new ArrayList<>();
    private List<String> messageHistory = new ArrayList<>();
    private Map<String, Integer> userMessageCount = new HashMap<>();

    @Override
    public void addUser(User user) {
        users.add(user);
        user.setMediator(this);
        String joinMessage = user.getName() + " 加入了聊天室";
        messageHistory.add(joinMessage);
        notifyUsers(joinMessage, user);
        System.out.println("用户 " + user.getName() + " 已加入聊天室");
    }

    @Override
    public void removeUser(User user) {
        users.remove(user);
        String leaveMessage = user.getName() + " 离开了聊天室";
        messageHistory.add(leaveMessage);
        notifyUsers(leaveMessage, null);
        userMessageCount.remove(user.getName());
        System.out.println("用户 " + user.getName() + " 已离开聊天室");
    }

    @Override
    public void sendMessage(String message, User sender) {
        String fullMessage = sender.getName() + ": " + message;
        messageHistory.add(fullMessage);

        // 统计用户消息数
        userMessageCount.put(sender.getName(),
                userMessageCount.getOrDefault(sender.getName(), 0) + 1);

        // 检查消息是否为命令
        if (message.startsWith("/")) {
            handleCommand(message, sender);
        } else {
            // 普通消息广播给所有其他用户
            for (User user : users) {
                if (user != sender) {
                    user.receive(fullMessage);
                }
            }
        }

        System.out.println("消息已发送：" + fullMessage);
    }

    @Override
    public void notifyUsers(String message, User excludeUser) {
        for (User user : users) {
            if (user != excludeUser) {
                user.receive("系统消息：" + message);
            }
        }
    }

    private void handleCommand(String command, User sender) {
        String[] parts = command.split(" ", 2);
        String cmd = parts[0].toLowerCase();

        switch (cmd) {
            case "/list":
                String userList = "在线用户：" + users.stream()
                        .map(User::getName)
                        .collect(Collectors.joining(", "));
                sender.receive(userList);
                break;

            case "/history":
                sender.receive("=== 聊天记录 ===");
                messageHistory.stream()
                        .skip(Math.max(0, messageHistory.size() - 10)) // 最近10条
                        .forEach(sender::receive);
                break;

            case "/stats":
                String stats = userMessageCount.entrySet().stream()
                        .map(entry -> entry.getKey() + ": " + entry.getValue() + "条消息")
                        .collect(Collectors.joining(", "));
                sender.receive("消息统计：" + stats);
                break;

            case "/private":
                if (parts.length > 1) {
                    handlePrivateMessage(parts[1], sender);
                } else {
                    sender.receive("用法：/private 用户名 消息内容");
                }
                break;

            case "/help":
                sender.receive("可用命令：/list, /history, /stats, /private, /help");
                break;

            default:
                sender.receive("未知命令：" + cmd + "，输入 /help 查看可用命令");
        }
    }

    private void handlePrivateMessage(String content, User sender) {
        String[] parts = content.split(" ", 2);
        if (parts.length < 2) {
            sender.receive("用法：/private 用户名 消息内容");
            return;
        }

        String targetName = parts[0];
        String message = parts[1];

        User target = users.stream()
                .filter(user -> user.getName().equals(targetName))
                .findFirst()
                .orElse(null);

        if (target != null) {
            target.receive("[私聊] " + sender.getName() + ": " + message);
            sender.receive("[私聊] 已发送给 " + targetName + ": " + message);
        } else {
            sender.receive("用户 " + targetName + " 不在线");
        }
    }

    public void showRoomStats() {
        System.out.println("=== 聊天室统计 ===");
        System.out.println("在线用户：" + users.size());
        System.out.println("历史消息：" + messageHistory.size());
        System.out.println("活跃用户：" + userMessageCount.size());
        System.out.println("================");
    }
}

// 用户抽象类
abstract class User {
    protected String name;
    protected ChatRoomMediator mediator;

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

    public void setMediator(ChatRoomMediator mediator) {
        this.mediator = mediator;
    }

    public String getName() {
        return name;
    }

    public abstract void send(String message);
    public abstract void receive(String message);
}

// 普通用户
class RegularUser extends User {
    public RegularUser(String name) {
        super(name);
    }

    @Override
    public void send(String message) {
        System.out.println(name + " 发送消息：" + message);
        if (mediator != null) {
            mediator.sendMessage(message, this);
        }
    }

    @Override
    public void receive(String message) {
        System.out.println(name + " 收到消息：" + message);
    }
}

// 管理员用户
class AdminUser extends User {
    public AdminUser(String name) {
        super(name);
    }

    @Override
    public void send(String message) {
        System.out.println("[管理员] " + name + " 发送消息：" + message);
        if (mediator != null) {
            mediator.sendMessage(message, this);
        }
    }

    @Override
    public void receive(String message) {
        System.out.println("[管理员] " + name + " 收到消息：" + message);
    }

    public void sendAnnouncement(String announcement) {
        System.out.println("[系统公告] " + announcement);
        if (mediator != null) {
            mediator.notifyUsers("📢 " + announcement, null);
        }
    }

    public void kickUser(User user) {
        System.out.println("[管理员] " + name + " 踢出用户：" + user.getName());
        if (mediator != null) {
            mediator.removeUser(user);
        }
    }
}

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

        // 创建用户
        User alice = new RegularUser("Alice");
        User bob = new RegularUser("Bob");
        User charlie = new RegularUser("Charlie");
        AdminUser admin = new AdminUser("Admin");

        // 用户加入聊天室
        chatRoom.addUser(alice);
        chatRoom.addUser(bob);
        chatRoom.addUser(charlie);
        chatRoom.addUser(admin);

        System.out.println("\n=== 聊天开始 ===");

        // 普通聊天
        alice.send("大家好！");
        Thread.sleep(1000);

        bob.send("你好 Alice！");
        Thread.sleep(1000);

        charlie.send("嗨，大家！");
        Thread.sleep(1000);

        // 使用命令
        System.out.println("\n=== 命令测试 ===");
        alice.send("/list");
        Thread.sleep(500);

        bob.send("/stats");
        Thread.sleep(500);

        // 私聊
        alice.send("/private Bob 你好，这是私聊消息");
        Thread.sleep(500);

        // 管理员功能
        System.out.println("\n=== 管理员功能 ===");
        admin.sendAnnouncement("欢迎大家来到聊天室！");
        Thread.sleep(1000);

        // 显示统计
        chatRoom.showRoomStats();

        // 用户离开
        System.out.println("\n=== 用户离开 ===");
        chatRoom.removeUser(charlie);
    }
}