Java Observer模式：如何实现对象间通信

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

在Java中，Observer模式主要通过以下几个接口和类来实现：

1. Observer接口：定义了观察者需要实现的更新方法。
2. Observable类：定义了被观察者需要实现的方法，用于管理观察者列表和通知观察者。

下面是一个简单的示例，展示了如何在Java中实现Observer模式：

1. 定义Observer接口

public interface Observer {
    void update(Observable o, Object arg);
}

2. 定义Observable类

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

public class Observable {
    private List<Observer> observers = new ArrayList<>();
    private boolean changed = false;

    public void addObserver(Observer o) {
        if (o == null) throw new NullPointerException();
        if (!observers.contains(o)) {
            observers.add(o);
        }
    }

    public void deleteObserver(Observer o) {
        observers.remove(o);
    }

    protected void setChanged() {
        changed = true;
    }

    protected void clearChanged() {
        changed = false;
    }

    public boolean hasChanged() {
        return changed;
    }

    public void notifyObservers(Object arg) {
        if (!changed) return;

        Object[] arrLocal;
        synchronized (this) {
            arrLocal = observers.toArray();
            clearChanged();
        }

        for (int i = 0; i < arrLocal.length; i++) {
            ((Observer) arrLocal[i]).update(this, arg);
        }
    }
}

3. 实现具体的观察者类

public class ConcreteObserver implements Observer {
    private String name;

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

    @Override
    public void update(Observable o, Object arg) {
        System.out.println(name + " received update: " + arg);
    }
}

4. 实现具体的被观察者类

public class ConcreteObservable extends Observable {
    private String state;

    public String getState() {
        return state;
    }

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

5. 测试Observer模式

public class ObserverPatternDemo {
    public static void main(String[] args) {
        ConcreteObservable observable = new ConcreteObservable();

        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        observable.addObserver(observer1);
        observable.addObserver(observer2);

        observable.setState("State 1");
        observable.setState("State 2");

        observable.deleteObserver(observer1);

        observable.setState("State 3");
    }
}

在这个示例中，ConcreteObservable类继承了Observable类，并在其setState方法中调用了setChanged和notifyObservers方法来通知观察者状态的变化。ConcreteObserver类实现了Observer接口，并在其update方法中处理接收到的更新。

通过这种方式，对象之间可以实现松耦合的通信，当一个对象的状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。