观察者模式-CSDN博客

本文链接：https://blog.csdn.net/Flying_Fish_roe/article/details/139550870

什么是观察者模式

观察者模式（Observer Pattern）是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听和被通知被观察者对象的改变。

在观察者模式中，有两个主要角色：

被观察者（Subject）：也称为主题或可观察对象，它持有一组观察者对象，并提供注册、删除和通知观察者的方法。
观察者（Observer）：也称为订阅者或监听器，它定义了接收被观察者通知的方法。

当被观察者的状态发生改变时，它会自动通知所有观察者对象，并调用它们的相应方法进行处理。观察者模式可以实现对象之间的解耦，当需要在对象之间建立一种一对多的依赖关系时，可以考虑使用观察者模式。

观察者模式的优点包括：灵活性高，可扩展性好，可以支持动态的变化。同时，也有一些缺点：观察者过多时可能会影响性能，观察者和被观察者之间可能存在循环引用问题。

观察者模式的职责

观察者模式的主要职责是定义了一种一对多的依赖关系，当一个对象的状态发生改变时，它的所有依赖者都会收到通知并自动更新。

具体来说，观察者模式的职责包括：

Subject（主题）：定义了被观察者的接口，其中包括了添加、删除和通知观察者的方法。主题对象一般维护一个或多个观察者对象的引用。
Observer（观察者）：定义了观察者的接口，其中包括了更新方法，用于接收被观察者发出的通知并进行相应的处理。
ConcreteSubject（具体主题）：具体主题是实现了主题接口的类，它维护着一个观察者列表，可以添加、删除和通知观察者。
ConcreteObserver（具体观察者）：具体观察者是实现了观察者接口的类，它具有与具体主题相对应的关联关系，在接收到通知后可以执行相应的操作。

观察者模式的职责是建立一种松耦合的关系，使得被观察者与观察者之间的依赖关系变得灵活，当被观察者的状态发生改变时，可以动态地通知观察者进行处理。这样可以实现对象之间的解耦，提高系统的可扩展性和可维护性。

观察者模式应用场景

当一个对象的改变需要通知其他对象，同时又不希望这些对象和被通知对象形成紧耦合关系时，可以使用观察者模式。例如，当一个订单状态发生改变时，需要通知相关的订单观察者对象更新状态。
当一个对象的改变会引起其他对象的连锁反应，需要自动更新相关对象的状态时，可以使用观察者模式。例如，当一个股票的价格发生变化时，需要通知股票观察者对象更新价格，同时也需要通知相关的用户观察者对象更新账户余额。
当一个对象需要将自己的状态变化通知给一组观察者对象，但不需要知道具体的观察者对象时，可以使用观察者模式。例如，一个新闻发布系统需要将新闻通知给订阅该类型新闻的所有观察者，但发布系统不需要了解具体的观察者是谁。
当一个对象需要在其内部状态改变时通知其他对象，并且不希望其他对象能够改变该对象的内部状态时，可以使用观察者模式。例如，一个游戏角色在受到攻击时需要通知其他角色更新血量，但不希望其他角色能够直接改变该角色的血量。

代码实现

观察者模式（Observer Pattern）是一种行为型设计模式，它定义了对象之间的一对多依赖关系，使得多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有观察者都会收到通知并自动更新。

以下是一个简单的Java代码实现观察者模式的例子：

import java.util.ArrayList;
import java.util.List;

// 主题接口
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具体主题
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

// 观察者接口
interface Observer {
    void update();
}

// 具体观察者
class ConcreteObserver implements Observer {
    private ConcreteSubject subject;

    public ConcreteObserver(ConcreteSubject subject) {
        this.subject = subject;
        subject.registerObserver(this);
    }

    @Override
    public void update() {
        System.out.println("Subject state changed, new state: " + subject.getState());
    }
}

// 测试代码
public class ObserverPatternDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        ConcreteObserver observer1 = new ConcreteObserver(subject);
        ConcreteObserver observer2 = new ConcreteObserver(subject);

        subject.setState(1);
        subject.setState(2);
        subject.setState(3);
    }
}

运行上述代码，输出结果如下：

Subject state changed, new state: 1
Subject state changed, new state: 1
Subject state changed, new state: 2
Subject state changed, new state: 2
Subject state changed, new state: 3
Subject state changed, new state: 3

在这个例子中，ConcreteSubject是具体的主题类，实现了Subject接口，负责注册、移除和通知观察者。ConcreteObserver是具体的观察者类，实现了Observer接口，负责接收并处理主题的变化通知。

在主函数中，我们创建了一个主题对象subject和两个观察者对象observer1和observer2，并演示了主题的状态变化对观察者的通知效果。