观察者模式

观察者模式的原理建立在一个简单但强大的概念上：对象之间的松耦合。在这种模式中，通常有两种主要的参与者：主题（Subject）和观察者（Observer）。

1. 主题 (Subject):

• 主题是被观察的对象。当其状态发生变化时，它需要通知所有的观察者。
• 主题维护一个观察者列表，以便知道要通知哪些对象。
• 主题提供方法，允许观察者注册自己或从主题注销。
• 当主题的状态发生变化时，它使用观察者接口中的方法通知所有已注册的观察者。

2. 观察者 (Observer):

• 观察者订阅主题，以便在主题状态变化时获得通知。
• 观察者通常提供一个回调方法，如update()，主题使用该方法来通知对应的观察者。

原理：

1. 松耦合: 之所以称之为松耦合是因为主题并不需要知道具体的观察者，只需知道观察者实现了观察者的接口。反之亦然，观察者不需要知道主题的具体实现，只需要知道主题包含注册和通知的方法。

2. 动态关系: 由于观察者与主题是动态关联的，所以你可以在运行时动态地添加或删除观察者。这种灵活性是观察者模式非常有用的原因之一。

3. 广播通信: 主题的状态一旦发生变化，所有的观察者都会得到通知（除非特定地只通知部分观察者）。这种通信方式类似于广播，一个消息被发送给所有的订阅者。

4. 抽象与封装: 观察者模式通过建立抽象主题和抽象观察者来封装细节。这意味着你可以独立地更改主题或观察者，而不影响到其他方面。

观察者模式经常用在各种系统中，特别是那些需要多个组件响应某些事件的系统。例如，GUI框架中，当用户点击按钮时，多个监听器（观察者）可能要对这个点击事件作出响应。这种模式还在很多其他情境中也很有用，比如股票市场更新、新闻发布等。

观察者模式是一种设计模式，其中一个对象（称为"主题"）维护一组依赖对象（称为"观察者"），当主题的状态发生变化时，它自动通知这些观察者。

以下是一个简单的Java示例，展示了观察者模式：

1. Observer 接口

这是所有观察者必须实现的接口，它定义了一个更新方法，以使观察者能够更新自己。

public interface Observer {
    void update(String message);
}
1
2
3

2. Subject 接口

这是主题必须实现的接口，它定义了添加、删除和通知观察者的方法。

public interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}
1
2
3
4
5

3. ConcreteSubject 类

这是主题的具体实现。它维护观察者列表并发送通知。

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

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String message;

    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

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

    public void setMessage(String message) {
        this.message = message;
        notifyObservers();
    }
}
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

4. ConcreteObserver 类

这是观察者的具体实现。

public class ConcreteObserver implements Observer {
    private String name;

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

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

5. 使用观察者模式

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

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

        subject.addObserver(observer1);
        subject.addObserver(observer2);

        subject.setMessage("Hello, Observers!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

当您运行上面的ObserverPatternDemo，您将看到以下输出：

Observer 1 received message: Hello, Observers!
Observer 2 received message: Hello, Observers!
1
2

这表明当ConcreteSubject的状态改变时，所有的观察者都被通知了。