设计模式(013)行为型之观察者模式

观察者模式是一种常见的软件设计模式，用于实现对象之间的一对多依赖关系。在观察者模式中，一个对象（称为主题或可观察对象）维护一个依赖列表，即一组观察者对象。当主题对象的状态发生变化时，它会自动通知所有观察者，使它们能够自动更新。

以下是观察者模式的基本组成部分：
① 主题（Subject） ：负责维护一组观察者对象，并提供注册、删除和通知观察者的方法。
② 观察者（Observer） ：定义一个更新方法，用于接收主题对象状态变化的通知。
③ 具体主题（ConcreteSubject） ：实现主题接口，维护其状态，并在状态发生变化时通知观察者。
④ 具体观察者（ConcreteObserver） ：实现观察者接口中的更新方法，并在收到通知时执行相应的操作。

观察者模式的优点包括：

松耦合性 ：主题对象和观察者对象之间的关系是松耦合的，它们之间并不直接依赖于彼此的具体实现。
- 可扩展性 ：可以轻松地添加新的观察者对象，而无需修改主题对象的代码。
- 封装变化 ：主题对象和观察者对象之间的通信逻辑被封装在了观察者模式中，使得系统更易于维护和修改。

观察者模式在软件开发中被广泛应用，特别是在需要实现对象间的一对多关系，并且希望避免对象之间紧密耦合的情况下。

1、场景设计

**实现场景：**定义一个主题，主题可以添加或删除观察者，主题可以通知数据变化，被添加(且未被删除)的观察者可以观察到主题的通知的数据变化。

2、C++实现

`ConcreteSubject` 类代表具体的主题，`ConcreteObserver` 类代表具体的观察者。主题维护了一个观察者列表，可以通过 `attach` 方法添加观察者，通过 `detach` 方法移除观察者，通过 `notify` 方法通知观察者。当主题状态发生变化时，它会调用 `notify` 方法通知所有注册的观察者。

cpp 复制代码

#include <iostream>
#include <vector>
#include <algorithm>

// 观察者基类
class Observer {
    public:
        virtual void update(int data) = 0;
};

// 具体观察者类
class ConcreteObserver : public Observer {
    public:
        void update(int data) override {
            std::cout << "ConcreteObserver received update with data: " << data << std::endl;
        }
};

// 主题基类
class Subject {
    public:
        virtual void attach(Observer* observer) = 0;
        virtual void detach(Observer* observer) = 0;
        virtual void notify(int data) = 0;
};

// 具体主题类
class ConcreteSubject : public Subject {
    private:
        std::vector<Observer*> observers;

    public:
        void attach(Observer* observer) override {
            observers.push_back(observer);
        }

        void detach(Observer* observer) override {
            auto it = std::find(observers.begin(), observers.end(), observer);
            if (it != observers.end()) {
                observers.erase(it);
            }
        }

        void notify(int data) override {
            for (auto observer : observers) {
                observer->update(data);
            }
        }
};

int main() {
    ConcreteSubject subject;

    ConcreteObserver observer1;
    ConcreteObserver observer2;

    subject.attach(&observer1);
    subject.attach(&observer2);

    subject.notify(10);

    subject.detach(&observer1);

    subject.notify(20);

    return 0;
}

3、Java实现

java 复制代码

package behavioralpattern.observer;
import java.util.ArrayList;
import java.util.List;
public class ObserverDemo {
    // 观察者接口
    interface Observer {
        void update(int data);
    }

    // 具体观察者类
    static class ConcreteObserver implements Observer {
        @Override
        public void update(int data) {
            System.out.println("ConcreteObserver received update with data: " + data);
        }
    }

    // 主题接口
    interface Subject {
        void attach(Observer observer);
        void detach(Observer observer);
        void notify(int data);
    }

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

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

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

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

    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        ConcreteObserver observer1 = new ConcreteObserver();
        ConcreteObserver observer2 = new ConcreteObserver();

        subject.attach(observer1);
        subject.attach(observer2);

        subject.notify(10);

        subject.detach(observer1);

        subject.notify(20);
    }
}