回答
观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会收到通知并自动更新。观察者模式用于构建通知机制，通常被用于事件驱动的系统中。
观察者模式的优点包括：
- 解耦：观察者与主题解耦，彼此独立变化。
- 动态订阅：观察者可以在运行时动态订阅或取消订阅主题。
- 自动更新：当主题状态变化时，所有观察者会自动收到通知并更新状态。
观察者模式的缺点包括：
- 通知开销：如果观察者数量众多，通知的开销可能会比较大。
- 可能导致循环依赖：多个观察者和主题之间可能形成循环依赖关系，导致系统问题。
- 无序通知：在某些情况下，观察者的通知顺序可能无法保证，影响依赖顺序的场景。
一个典型的例子是天气监控系统。气象站（主题）会监控天气变化，并通知所有显示设备（观察者）。当气象站的天气数据发生变化时，所有注册的显示设备会自动更新其显示内容。
1. 什么是观察者模式？
观察者模式（Observer Pattern）是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会收到通知并自动更新。
观察者模式也被称为发布-订阅模式（Publish-Subscribe Pattern），它主要用于构建一个通知机制，让对象之间能够自动地通知和更新状态。
在观察者模式中，被观察的对象称为“主题”（Subject），而那些依赖主题的对象称为“观察者”（Observer）。当主题发生变化时，观察者会自动收到通知并进行相应的处理。
2. 观察者模式的结构
观察者模式通常包含以下几个角色：
- 主题（Subject）：提供注册、移除和通知观察者的方法。主题知道它的观察者，并维护观察者的列表。
- 观察者（Observer）：定义一个接口，用于接收主题的通知更新。
- 具体主题（ConcreteSubject）：实现了主题接口，维护主题的状态，当状态发生变化时，通知所有注册的观察者。
- 具体观察者（ConcreteObserver）：实现观察者接口，并在收到通知时更新自身状态。
3. 观察者模式的实现
以下是一个使用 Java 实现观察者模式的示例，假设我们有一个气象站系统，它会监控天气变化并通知多个显示设备。
1. 定义观察者接口
1
2
3
4
| java复制代码// 观察者接口，定义更新方法
public interface Observer {
void update(float temperature, float humidity, float pressure);
}
|
2. 定义主题接口
1
2
3
4
5
6
| java复制代码// 主题接口，定义注册、移除和通知观察者的方法
public interface Subject {
void registerObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers();
}
|
3. 实现具体主题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
| java复制代码import java.util.ArrayList;
import java.util.List;
// 具体主题，实现主题接口
public class WeatherData implements Subject {
private List<Observer> observers;
private float temperature;
private float humidity;
private float pressure;
public WeatherData() {
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(temperature, humidity, pressure);
}
}
// 设置天气数据，并通知观察者
public void setMeasurements(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
notifyObservers();
}
}
|
4. 实现具体观察者
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| java复制代码// 具体观察者，实现观察者接口
public class CurrentConditionsDisplay implements Observer {
private float temperature;
private float humidity;
@Override
public void update(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
display();
}
public void display() {
System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
}
}
|
5. 使用观察者模式
1
2
3
4
5
6
7
8
9
10
11
| java复制代码public class WeatherStation {
public static void main(String[] args) {
WeatherData weatherData = new WeatherData();
CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay();
weatherData.registerObserver(currentDisplay);
weatherData.setMeasurements(80, 65, 30.4f); // 输出: Current conditions: 80.0F degrees and 65.0% humidity
weatherData.setMeasurements(82, 70, 29.2f); // 输出: Current conditions: 82.0F degrees and 70.0% humidity
}
}
|
6. 运行结果
1
2
| sql复制代码Current conditions: 80.0F degrees and 65.0% humidity
Current conditions: 82.0F degrees and 70.0% humidity
|
4. 观察者模式的优点
- 解耦：观察者模式将观察者与主题解耦，使得它们可以独立变化。主题不知道观察者的具体实现，观察者也不知道其他观察者的存在。
- 动态订阅：观察者可以在运行时动态地订阅或取消订阅主题，灵活性很高。
- 自动更新：当主题状态发生变化时，所有观察者会自动收到通知并更新状态，减少了手动通知和更新的工作量。
5. 观察者模式的缺点
- 通知开销：如果观察者的数量很多，通知所有观察者可能会带来性能开销，尤其是在同步通知的情况下。
- 可能导致循环依赖：如果多个观察者和主题之间形成循环依赖关系，可能导致系统出现问题，如无限循环。
- 无序通知：在某些情况下，观察者的通知顺序可能无法保证，这在依赖顺序的场景中可能会带来问题。
