设计模式 – 观察者模式（Observer Pattern）

观察者模式（Observer Pattern）是一种行为设计模式，它定义了一种一对多的依赖关系，当一个对象（主题）的状态发生变化时，所有依赖于它的对象（观察者）都会得到通知并自动更新。这有助于实现对象之间的解耦，让对象间的通信更加灵活。

Java 示例代码：

首先，我们创建一个观察者接口：

public interface Observer {
    void update(String message);
}

接着，我们创建一个主题接口：

public interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

然后，我们创建一个具体主题类，实现 Subject 接口：

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

public class ConcreteSubject implements Subject {
    private List<Observer> observers;
    private String message;

    public ConcreteSubject() {
        observers = new ArrayList<>();
    }

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

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

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

    public void setMessage(String message) {
        this.message = message;
        notifyObservers();
    }
}

接下来，我们创建两个具体的观察者类，实现 Observer 接口：

public class ConcreteObserverA implements Observer {
    @Override
    public void update(String message) {
        System.out.println("ConcreteObserverA received the message: " + message);
    }
}

public class ConcreteObserverB implements Observer {
    @Override
    public void update(String message) {
        System.out.println("ConcreteObserverB received the message: " + message);
    }
}

现在，我们可以在客户端代码中使用这些类：

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

        Observer observerA = new ConcreteObserverA();
        Observer observerB = new ConcreteObserverB();

        subject.addObserver(observerA);
        subject.addObserver(observerB);

        subject.setMessage("Hello, Observers!");
        System.out.println("--------------------");
        subject.setMessage("Another message for Observers");
    }
}

输出：

ConcreteObserverA received the message: Hello, Observers!
ConcreteObserverB received the message: Hello, Observers!
--------------------
ConcreteObserverA received the message: Another message for Observers
ConcreteObserverB received the message: Another message for Observers

观察者模式的关键在于主题和观察者之间的解耦。当主题的状态发生变化时，所有依赖于它的观察者都会得到通知并自动更新。这样，当我们需要添加新的观察者或修改现有

---

观察者模式是一种行为设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件处理系统和发布/订阅系统。

Java 示例代码：

首先，我们定义一个观察者接口：

public interface Observer {
    void update(Object data);
}

然后，我们定义一个主题接口，它包含添加、删除观察者和通知观察者的方法：

public interface Subject {
    void addObserver(Observer observer);

    void removeObserver(Observer observer);

    void notifyObservers();
}

接下来，我们创建一个具体的主题类，实现 Subject 接口：

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

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private Object data;

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

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

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

    // 当数据发生变化时，调用此方法通知所有观察者
    public void setData(Object data) {
        this.data = data;
        notifyObservers();
    }
}

现在我们创建一个具体的观察者类，实现 Observer 接口：

public class ConcreteObserver implements Observer {
    private String observerName;

    public ConcreteObserver(String observerName) {
        this.observerName = observerName;
    }

    @Override
    public void update(Object data) {
        System.out.println(observerName + " received data: " + data);
    }
}

最后，我们可以在客户端代码中使用这些类：

public class Client {
    public static void main(String[] args) {
        // 创建主题
        ConcreteSubject subject = new ConcreteSubject();

        // 创建并注册观察者
        Observer observer1 = new ConcreteObserver("Observer1");
        Observer observer2 = new ConcreteObserver("Observer2");
        subject.addObserver(observer1);
        subject.addObserver(observer2);

        // 改变主题的状态
        subject.setData("Hello, Observers!");

        // 移除一个观察者并再次改变主题的状态
        subject.removeObserver(observer1);
        subject.setData("Observer1 is removed.");
    }
}

输出：

Observer1 received data: Hello, Observers!
Observer2 received data: Hello, Observers!
Observer2 received data: Observer1 is removed.

通过这个示例，你可以看到观察者模式如何实现对象之间的一对多依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这有助于实现松耦合的系统设计。