## **模式的定义**
观察者模式主要用于1对N的通知。当一个对象的状态变化时，他需要及时告知一系列对象，令他们做出相应。
## **代码实现**
1. 定义观察者接口
```
public interface Observer {
// 接到通知后的处理
void update(Subject subject);
}
```
2. 实现观察者方法
```
public class ObserverImpl implements Observer {
@Override
public void update(Subject subject) {
System.out.println("观察者修改数据:" + subject.getData());
}
}
```
3. 创建抽象的观察的主题
```
public abstract class Subject {
// 存储观察者的列表
private List<Observer> observers = new ArrayList<>();
// 注册观察者
public void registerObserver(Observer obs) {
observers.add(obs);
}
// 删除观察者
public void removerObserver(Observer obs) {
observers.remove(obs);
}
// 广播
public void broadcast() {
for (Observer observer : observers) {
observer.update(this);
}
}
// 留给子类实现的抽象方法
public abstract Object getData();
}
```
4. 创建具体的观察主题
```
public class SubjectA extends Subject {
private int state;
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
this.broadcast();
}
@Override
public Object getData() {
return state;
}
}
```
5. 客户端调用
```
public static void main(String[] args) {
// 实例化多个观察者
ObserverImpl obs1 = new ObserverImpl();
ObserverImpl obs2 = new ObserverImpl();
ObserverImpl obs3 = new ObserverImpl();
// 创建观察主题
SubjectA subject = new SubjectA();
// 注册观察者
subject.registerObserver(obs1);
subject.registerObserver(obs2);
subject.registerObserver(obs3);
subject.setState(100);
}
```
执行结果
```
观察者修改数据:100
观察者修改数据:100
观察者修改数据:100
```
