Observer模式在Java中怎么用

Observer模式是一种行为设计模式，它定义了对象之间的一对多依赖关系，使得当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。在Java中，Observer模式主要通过java.util.Observer接口和java.util.Observable类来实现。

以下是使用Observer模式的基本步骤：

1. 定义观察者（Observer）： 观察者需要实现Observer接口，该接口包含一个update(Observable o, Object arg)方法，当被观察者状态改变时，这个方法会被调用。

   import java.util.Observer;
   
   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);
       }
   }
   

2. 定义被观察者（Observable）： 被观察者需要继承Observable类，并在状态改变时调用setChanged()和notifyObservers(Object o)方法来通知观察者。

   import java.util.Observable;
   
   public class ConcreteObservable extends Observable {
       private String state;
   
       public void setState(String state) {
           this.state = state;
           setChanged(); // 标记状态已经改变
           notifyObservers(state); // 通知观察者
       }
   }
   

3. 使用观察者模式： 创建被观察者和观察者的实例，并将观察者注册到被观察者中。然后改变被观察者的状态，触发通知。

   public class ObserverPatternDemo {
       public static void main(String[] args) {
           ConcreteObservable observable = new ConcreteObservable();
   
           ConcreteObserver observer1 = new ConcreteObserver("Observer 1");
           ConcreteObserver 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的状态改变时，所有注册的ConcreteObserver实例都会收到通知并执行它们的update方法。

需要注意的是，从Java 9开始，Observable和Observer类已经被标记为过时（deprecated），推荐使用其他机制来实现观察者模式，例如使用java.beans.PropertyChangeListener和java.beans.PropertyChangeSupport，或者使用第三方库如RxJava等。

以下是使用PropertyChangeListener和PropertyChangeSupport的示例：

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;

public class ConcreteObservable {
    private String state;
    private final PropertyChangeSupport support;

    public ConcreteObservable() {
        support = new PropertyChangeSupport(this);
    }

    public void addPropertyChangeListener(PropertyChangeListener pcl) {
        support.addPropertyChangeListener(pcl);
    }

    public void removePropertyChangeListener(PropertyChangeListener pcl) {
        support.removePropertyChangeListener(pcl);
    }

    public void setState(String newState) {
        String oldState = this.state;
        this.state = newState;
        support.firePropertyChange(oldState, newState, null);
    }
}

public class ConcretePropertyChangeListener implements PropertyChangeListener {
    private String name;

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

    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        System.out.println(name + " received update: " + evt.getNewValue());
    }
}

使用这种方式，你可以更灵活地处理属性变化事件，并且避免了Observable和Observer类的过时问题。