前言:
行为型设计模式实际使用场景第二部分;
1.中介者模式（Mediator）
概念:
它定义了一个中介类来封装一系列对象之间的交互，从而使各个对象不需要显式地相互引用，降低耦合度，提高系统的可维护性和扩展性。中介者模式让多个对象通过一个中介对象来通信，而不是互相引用。
实际使用场景:
设想一个聊天室应用，其中包含多个用户。用户之间可以通过聊天室发送消息，但为了简化管理，我们不希望每个用户直接与其他用户建立连接，而是通过一个聊天室中介者来协调消息的传递。这样，新增或移除用户时，只需要更改中介者，而不用修改每个用户类。
直接上代码:
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<>();}@Overridepublic 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);}@Overridepublic 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类作为具体同事类，它们不知道其他用户的直接引用，而是通过调用中介者（聊天室）的方法来发送消息。这样，即使添加或删除用户，也只需要修改中介者的状态，而无需修改用户类，大大降低了耦合度，体现了中介者模式的优点。
2.备忘录模式（Memento）
概念:
它提供了一种在不破坏封装性的前提下，捕获一个对象的内部状态，并在将来恢复该对象状态的方法。这个模式非常适合需要实现撤销操作的场景，比如文本编辑器的撤销功能、游戏的存档与读档功能等。
实际使用场景:
假设我们正在开发一个文本编辑器应用，用户在编辑文本时可能会希望保存当前的编辑状态，以便在未来某个时刻可以恢复到这一状态。这里，我们可以使用备忘录模式来设计文本编辑器的状态保存与恢复功能。
直接上代码:
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类是备忘录，存储了文本编辑器的内部状态（即文本内容）。客户端代码模拟了用户编辑文本、保存状态以及恢复到之前保存状态的过程。备忘录模式允许我们在不影响原发器类设计的情况下，保存和恢复对象的状态，这对于需要实现撤销/重做功能的应用来说非常有用。
3.观察者模式（Observer）
概念:
它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件处理系统、实时数据更新等场景。
实际使用场景:
假设我们正在开发一个天气预报系统，用户可以订阅不同的城市天气预报。当某个城市的天气发生变化时，系统需要即时通知所有订阅该城市天气预报的用户。这是一个典型的观察者模式应用场景。
直接上代码:
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<>();}@Overridepublic void registerObserver(WeatherObserver observer) {observers.add(observer);}@Overridepublic void removeObserver(WeatherObserver observer) {observers.remove(observer);}@Overridepublic 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;}@Overridepublic 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种具体设计模式的使用场景;第三部分下期见.
