什么是Java中的观察者模式？

Java中的观察者模式是一种设计模式，它允许一个对象在状态发生改变时通知它的所有观察者。这种模式在许多情况下都非常有用，例如在用户界面中，当用户与界面交互时，可能需要通知其他对象。

下面是一个简单的Java代码示例，演示了观察者模式的基本用法：

public interface Observer {
    void update();
}

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

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    
    @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 class ConcreteObserver implements Observer {
    private ConcreteSubject subject;
    
    @Override
    public void update() {
        subject.notifyObservers();
    }
}

在这个例子中，我们定义了两个接口：Observer和Subject。Observer表示观察者，它有一个update()方法，当观察者需要被通知时，它会调用这个方法。Subject表示被观察者，它有一个registerObserver()方法用于添加观察者，一个removeObserver()方法用于删除观察者，以及一个notifyObservers()方法用于通知所有观察者。我们还定义了一个ConcreteSubject类来实现Subject接口，并实现了一个ConcreteObserver类来实现Observer接口。最后，我们在ConcreteSubject中实现了通知所有观察者的方法。

---

下面又是一个简单的Java代码示例：

// 定义一个观察者接口
interface Observer {
    void update();
}

// 定义一个被观察者类
class Subject {
    private List<Observer> observers = new ArrayList<>();

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

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

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

// 定义一个实现观察者接口的类
class ConcreteObserver1 implements Observer {
    @Override
    public void update() {
        System.out.println("ConcreteObserver1 updated");
    }
}

class ConcreteObserver2 implements Observer {
    @Override
    public void update() {
        System.out.println("ConcreteObserver2 updated");
    }
}

// 测试代码
public class ObserverPatternDemo {
    public static void main(String[] args) {
        Subject subject = new Subject();
        ConcreteObserver1 observer1 = new ConcreteObserver1();
        ConcreteObserver2 observer2 = new ConcreteObserver2();
        subject.attach(observer1);
        subject.attach(observer2);
        subject.notifyObservers(); // 输出：ConcreteObserver1 updated和ConcreteObserver2 updated
        subject.detach(observer1); // 输出：ConcreteObserver2 updated，因为observer1已经被移除掉了
        subject.notifyObservers(); // 输出：ConcreteObserver2 updated，因为只有observer2被通知了，而observer1已经被移除掉了
    }
}

在这个示例中，我们定义了一个Subject类作为被观察者，它维护了一个观察者列表，并实现了attach和detach方法来添加和移除观察者。我们还定义了一个Observer接口，它包含了一个update方法，用于通知观察者状态已经改变。最后，我们定义了两个实现Observer接口的类ConcreteObserver1和ConcreteObserver2，它们分别实现了update方法。在测试代码中，我们创建了一个Subject对象，并添加了两个观察者ConcreteObserver1和ConcreteObserver2。然后我们调用Subject的notifyObservers方法来通知所有观察者状态已经改变，并打印出观察者的更新信息。接着我们移除了观察者ConcreteObserver1，再次调用notifyObservers方法时，只有ConcreteObserver2被通知了。