Java Observer 模式如何实现解耦

在 Java 中，观察者模式（Observer Pattern）是一种行为设计模式，它允许对象（观察者）订阅另一个对象（主题）的状态变化，并在状态发生变化时自动通知观察者。这种模式有助于实现对象之间的解耦，因为观察者不需要知道主题的内部实现细节，只需要关注主题提供的接口。

以下是使用 Java 实现观察者模式的步骤：

1. 定义一个主题接口（Subject）：

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

2. 定义一个观察者接口（Observer）：

public interface Observer {
    void update();
}

3. 创建一个具体的主题类（ConcreteSubject），实现 Subject 接口：

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

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

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

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

    public int getState() {
        return state;
    }
}

4. 创建一个具体的观察者类（ConcreteObserver），实现 Observer 接口：

public class ConcreteObserver implements Observer {
    private String name;

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

    @Override
    public void update() {
        System.out.println(name + " received update, current state: " + ((ConcreteSubject) getSubject()).getState());
    }

    public void setSubject(Subject subject) {
        ((ConcreteSubject) subject).registerObserver(this);
    }

    public void removeSubject() {
        ((ConcreteSubject) getSubject()).removeObserver(this);
    }

    public Subject getSubject() {
        // 这里假设观察者持有一个对主题的引用，以便在需要时获取主题并调用其方法
        // 在实际应用中，这种设计可能会导致循环引用和内存泄漏，因此需要谨慎使用
        return null;
    }
}

5. 在客户端代码中使用观察者模式：

public class Client {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        observer1.setSubject(subject);
        observer2.setSubject(subject);

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

        observer1.removeSubject();

        subject.setState(3);
    }
}

在这个例子中，我们创建了一个具体的主题类 ConcreteSubject 和两个具体的观察者类 ConcreteObserver。客户端代码创建了主题和观察者的实例，并将观察者注册到主题。当主题的状态发生变化时，观察者会自动收到通知并更新其状态。通过这种方式，观察者和主题之间的耦合度降低，因为它们只需要关注彼此的接口。