前言:
行为型设计模式实际使用场景第二部分;
它定义了一个中介类来封装一系列对象之间的交互，从而使各个对象不需要显式地相互引用，降低耦合度，提高系统的可维护性和扩展性。中介者模式让多个对象通过一个中介对象来通信，而不是互相引用。
设想一个聊天室应用，其中包含多个用户。用户之间可以通过聊天室发送消息，但为了简化管理，我们不希望每个用户直接与其他用户建立连接，而是通过一个聊天室中介者来协调消息的传递。这样，新增或移除用户时，只需要更改中介者，而不用修改每个用户类。
a.抽象中介者
public interface ChatRoomMediator {
void sendMessage(String message, User user);
}
b.具体中介者
public class ChatRoom implements ChatRoomMediator {
private List<User> users;
public ChatRoom() {
this.users = new ArrayList<>();
}
@Override
public void sendMessage(String message, User user) {
for (User u : users) {
if (!u.equals(user)) {
u.receive(message);
}
}
}
public void addUser(User user) {
users.add(user);
user.setChatRoom(this);
}
}
c.抽象同事类
public abstract class User {
protected String name;
protected ChatRoomMediator chatRoom;
public User(String name) {
this.name = name;
}
public abstract void receive(String message);
public void setChatRoom(ChatRoomMediator chatRoom) {
this.chatRoom = chatRoom;
}
}
d.具体同事类
public class UserImpl extends User {
public UserImpl(String name) {
super(name);
}
@Override
public void receive(String message) {
System.out.println(name + " received: " + message);
}
public void sendMessage(String message) {
chatRoom.sendMessage(message, this);
}
}
e.客户端代码
public class MediatorPatternDemo {
public static void main(String[] args) {
ChatRoom chatRoom = new ChatRoom();
UserImpl user1 = new UserImpl("Alice");
UserImpl user2 = new UserImpl("Bob");
chatRoom.addUser(user1);
chatRoom.addUser(user2);
user1.sendMessage("Hello, Bob!");
user2.sendMessage("Hi, Alice!");
}
}
解释
在这个例子中，ChatRoom类作为中介者，管理用户间的通信。UserImpl类作为具体同事类，它们不知道其他用户的直接引用，而是通过调用中介者（聊天室）的方法来发送消息。这样，即使添加或删除用户，也只需要修改中介者的状态，而无需修改用户类，大大降低了耦合度，体现了中介者模式的优点。
它提供了一种在不破坏封装性的前提下，捕获一个对象的内部状态，并在将来恢复该对象状态的方法。这个模式非常适合需要实现撤销操作的场景，比如文本编辑器的撤销功能、游戏的存档与读档功能等。
假设我们正在开发一个文本编辑器应用，用户在编辑文本时可能会希望保存当前的编辑状态，以便在未来某个时刻可以恢复到这一状态。这里，我们可以使用备忘录模式来设计文本编辑器的状态保存与恢复功能。
a.备忘录类（Memento）
public class EditorMemento {
private String content;
public EditorMemento(String content) {
this.content = content;
}
public String getContent() {
return content;
}
}
b.原发器类（Originator）
public class TextEditor {
private String content;
public void type(String text) {
content += text;
System.out.println("Typed: " + text);
}
public EditorMemento save() {
return new EditorMemento(content);
}
public void restore(EditorMemento memento) {
content = memento.getContent();
System.out.println("Restored content: " + content);
}
}
c.客户端代码
public class MementoPatternDemo {
public static void main(String[] args) {
TextEditor editor = new TextEditor();
// 编辑文本
editor.type("Hello, ");
editor.type("World!");
// 保存当前状态
EditorMemento savedState = editor.save();
// 继续编辑
editor.type(" How are you?");
// 恢复到保存的状态
editor.restore(savedState);
}
}
解释
在这个例子中，TextEditor类是原发器，它负责创建和恢复文本的状态。EditorMemento类是备忘录，存储了文本编辑器的内部状态（即文本内容）。客户端代码模拟了用户编辑文本、保存状态以及恢复到之前保存状态的过程。备忘录模式允许我们在不影响原发器类设计的情况下，保存和恢复对象的状态，这对于需要实现撤销/重做功能的应用来说非常有用。
它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件处理系统、实时数据更新等场景。
假设我们正在开发一个天气预报系统，用户可以订阅不同的城市天气预报。当某个城市的天气发生变化时，系统需要即时通知所有订阅该城市天气预报的用户。这是一个典型的观察者模式应用场景。
a.抽象主题（Subject）
public interface WeatherSubject {
void registerObserver(WeatherObserver observer);
void removeObserver(WeatherObserver observer);
void notifyObservers(String city, String weather);
}
b.具体主题（Concrete Subject）
import java.util.ArrayList;
import java.util.List;
public class WeatherDataCenter implements WeatherSubject {
private List<WeatherObserver> observers;
private String currentCity;
private String currentWeather;
public WeatherDataCenter() {
this.observers = new ArrayList<>();
}
@Override
public void registerObserver(WeatherObserver observer) {
observers.add(observer);
}
@Override
public void removeObserver(WeatherObserver observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(String city, String weather) {
currentCity = city;
currentWeather = weather;
for (WeatherObserver observer : observers) {
observer.update(city, weather);
}
}
public void setWeather(String city, String weather) {
System.out.println("Weather update: " + city + ", " + weather);
notifyObservers(city, weather);
}
}
c.抽象观察者（Observer）
public interface WeatherObserver {
void update(String city, String weather);
}
d.具体观察者（Concrete Observer）
public class User implements WeatherObserver {
private String name;
private String subscribedCity;
public User(String name, String subscribedCity) {
this.name = name;
this.subscribedCity = subscribedCity;
}
@Override
public void update(String city, String weather) {
if (this.subscribedCity.equals(city)) {
System.out.println(name + " received update: " + city + " weather is " + weather);
}
}
}
e.客户端代码
public class ObserverPatternDemo {
public static void main(String[] args) {
WeatherSubject weatherDataCenter = new WeatherDataCenter();
WeatherObserver user1 = new User("Alice", "New York");
WeatherObserver user2 = new User("Bob", "San Francisco");
weatherDataCenter.registerObserver(user1);
weatherDataCenter.registerObserver(user2);
weatherDataCenter.setWeather("New York", "Sunny");
weatherDataCenter.setWeather("San Francisco", "Foggy");
}
}
解释
在这个例子中，WeatherDataCenter作为被观察的主题，维护了一个观察者列表，并负责在天气信息更新时通知所有观察者。User类作为观察者，实现了WeatherObserver接口，当接收到更新通知时，会检查是否是自己订阅的城市，如果是，则打印出更新信息。这样，当天气数据发生变化时，所有订阅该天气信息的用户都能及时得到通知，而无需知道具体的用户实现细节，实现了低耦合的设计。
好了以上就是行为型设计模式的3种具体设计模式的使用场景;第三部分下期见.