前言:
行为型设计模式实际使用场景第二部分;
1.中介者模式(Mediator)
概念:
它定义了一个中介类来封装一系列对象之间的交互,从而使各个对象不需要显式地相互引用,降低耦合度,提高系统的可维护性和扩展性。中介者模式让多个对象通过一个中介对象来通信,而不是互相引用。
实际使用场景:
设想一个聊天室应用,其中包含多个用户。用户之间可以通过聊天室发送消息,但为了简化管理,我们不希望每个用户直接与其他用户建立连接,而是通过一个聊天室中介者来协调消息的传递。这样,新增或移除用户时,只需要更改中介者,而不用修改每个用户类。
直接上代码:
a.抽象中介者
java
public interface ChatRoomMediator {
void sendMessage(String message, User user);
}
b.具体中介者
java
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.抽象同事类
java
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.具体同事类
java
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.客户端代码
java
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)
java
public class EditorMemento {
private String content;
public EditorMemento(String content) {
this.content = content;
}
public String getContent() {
return content;
}
}
b.原发器类(Originator)
java
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.客户端代码
java
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)
java
public interface WeatherSubject {
void registerObserver(WeatherObserver observer);
void removeObserver(WeatherObserver observer);
void notifyObservers(String city, String weather);
}
b.具体主题(Concrete Subject)
java
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)
java
public interface WeatherObserver {
void update(String city, String weather);
}
d.具体观察者(Concrete Observer)
java
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.客户端代码
java
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种具体设计模式的使用场景;第三部分下期见.