设计模式：行为型（Behavioral）

 1 // 抽象处理者
 2 abstract class Handler {
 3     protected Handler nextHandler; // 下一个处理者
 4 
 5     public void setNextHandler(Handler nextHandler) {
 6         this.nextHandler = nextHandler;
 7     }
 8 
 9     public abstract void handleRequest(int level);
10 }
11 
12 // 具体处理者
13 class ConcreteHandler1 extends Handler {
14     @Override
15     public void handleRequest(int level) {
16         if (level <= 10) {
17             System.out.println("ConcreteHandler1处理了请求");
18         } else if (nextHandler != null) {
19             nextHandler.handleRequest(level);
20         }
21     }
22 }
23 
24 class ConcreteHandler2 extends Handler {
25     @Override
26     public void handleRequest(int level) {
27         if (level > 10 && level <= 20) {
28             System.out.println("ConcreteHandler2处理了请求");
29         } else if (nextHandler != null) {
30             nextHandler.handleRequest(level);
31         }
32     }
33 }
34 
35 class ConcreteHandler3 extends Handler {
36     @Override
37     public void handleRequest(int level) {
38         if (level > 20) {
39             System.out.println("ConcreteHandler3处理了请求");
40         } else if (nextHandler != null) {
41             nextHandler.handleRequest(level);
42         }
43     }
44 }
45 
46 // 客户端
47 public class Client {
48     public static void main(String[] args) {
49         Handler handler1 = new ConcreteHandler1();
50         Handler handler2 = new ConcreteHandler2();
51         Handler handler3 = new ConcreteHandler3();
52 
53         handler1.setNextHandler(handler2);
54         handler2.setNextHandler(handler3);
55 
56         // 发送请求
57         handler1.handleRequest(5);
58         handler1.handleRequest(15);
59         handler1.handleRequest(25);
60     }
61 }

 1 // 中介者接口
 2 public interface ChatRoomMediator {
 3     void sendMessage(String message, User user);
 4     void addUser(User user);
 5 }
 6 
 7 // 具体中介者
 8 public class ChatRoom implements ChatRoomMediator {
 9     private List<User> users = new ArrayList<>();
10 
11     @Override
12     public void sendMessage(String message, User user) {
13         for (User u : users) {
14             if (u != user) {
15                 u.receiveMessage(message);
16             }
17         }
18     }
19 
20     @Override
21     public void addUser(User user) {
22         users.add(user);
23     }
24 }
25 
26 // 同事类
27 public class User {
28     private String name;
29     private ChatRoomMediator mediator;
30 
31     public User(String name, ChatRoomMediator mediator) {
32         this.name = name;
33         this.mediator = mediator;
34     }
35 
36     public void sendMessage(String message) {
37         System.out.println(name + " sends message: " + message);
38         mediator.sendMessage(message, this);
39     }
40 
41     public void receiveMessage(String message) {
42         System.out.println(name + " receives message: " + message);
43     }
44 }
45 
46 // 客户端使用示例
47 public class Client {
48     public static void main(String[] args) {
49         ChatRoomMediator mediator = new ChatRoom();
50         User user1 = new User("User1", mediator);
51         User user2 = new User("User2", mediator);
52         User user3 = new User("User3", mediator);
53 
54         mediator.addUser(user1);
55         mediator.addUser(user2);
56         mediator.addUser(user3);
57 
58         user1.sendMessage("Hello, everyone!");
59         user2.sendMessage("Hi, User1!");
60     }
61 }

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 
 4 // 主题（被观察者）
 5 interface Subject {
 6     void registerObserver(Observer observer); // 注册观察者
 7     void unregisterObserver(Observer observer); // 取消注册观察者
 8     void notifyObservers(String news); // 通知观察者
 9 }
10 
11 // 观察者
12 interface Observer {
13     void update(String news); // 更新方法
14 }
15 
16 // 具体主题（具体被观察者）
17 class NewsPublisher implements Subject {
18     private List<Observer> observers = new ArrayList<>();
19     private String news;
20 
21     @Override
22     public void registerObserver(Observer observer) {
23         observers.add(observer);
24     }
25 
26     @Override
27     public void unregisterObserver(Observer observer) {
28         observers.remove(observer);
29     }
30 
31     @Override
32     public void notifyObservers(String news) {
33         this.news = news;
34         for (Observer observer : observers) {
35             observer.update(news);
36         }
37     }
38 }
39 
40 // 具体观察者
41 class NewsSubscriber implements Observer {
42     private String name;
43 
44     public NewsSubscriber(String name) {
45         this.name = name;
46     }
47 
48     @Override
49     public void update(String news) {
50         System.out.println(name + " 收到了新闻：" + news);
51     }
52 }
53 
54 public class ObserverPatternExample {
55     public static void main(String[] args) {
56         NewsPublisher publisher = new NewsPublisher(); // 创建新闻发布者
57 
58         Observer subscriber1 = new NewsSubscriber("Subscriber 1"); // 创建订阅者1
59         Observer subscriber2 = new NewsSubscriber("Subscriber 2"); // 创建订阅者2
60 
61         publisher.registerObserver(subscriber1); // 注册订阅者1
62         publisher.registerObserver(subscriber2); // 注册订阅者2
63 
64         publisher.notifyObservers("Breaking News: COVID-19 Vaccine Released!"); // 发布新闻
65 
66         publisher.unregisterObserver(subscriber1); // 取消注册订阅者1
67 
68         publisher.notifyObservers("Latest News: Economic Growth Forecast Revised!"); // 发布新闻
69 
70     }
71 }