浅谈Java23种设计模式之11种行为型模式的使用场景(第二部分)

前言:
行为型设计模式实际使用场景第二部分;

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<>();
    }

    @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类作为具体同事类，它们不知道其他用户的直接引用，而是通过调用中介者（聊天室）的方法来发送消息。这样，即使添加或删除用户，也只需要修改中介者的状态，而无需修改用户类，大大降低了耦合度，体现了中介者模式的优点。

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<>();
    }

    @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种具体设计模式的使用场景;第三部分下期见.