Java 事件处理基础 Observer设计模式

封面图 • 2025-09-16 • Java

在 Java 中，**事件处理** 是一种常见的编程机制，用于实现程序中不同组件之间的通信。Java 通过 **观察者设计模式（Observer Design Pattern）** 来实现事件处理系统。

---

## 🧠 一、什么是观察者设计模式？

**观察者设计模式** 是一种行为型设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会收到通知并自动更新。

### 核心概念：

- **Subject（主题）**：被观察的对象，维护一个观察者列表，并提供注册、移除和通知观察者的方法。
- **Observer（观察者）**：当主题状态变化时，接收通知的接口或类。
- **ConcreteSubject（具体主题）**：实现 Subject 接口，包含具体的状态，并在状态变化时通知观察者。
- **ConcreteObserver（具体观察者）**：实现 Observer 接口，响应主题的通知。

---

## 🧩 二、Java 中的事件处理与观察者模式

Java 的标准事件处理机制（如 AWT 和 Swing 中的 GUI 事件）就是基于观察者模式实现的。

### 1. `java.util.Observer` 接口（已过时）

在早期的 Java 版本中，`java.util.Observer` 接口和 `java.util.Observable` 类是观察者模式的标准实现。但这些类已经被标记为 **过时（deprecated）**，推荐使用更现代的方式（如 `java.beans.PropertyChangeSupport` 或自定义实现）。

#### 示例（已过时）：

```java
import java.util.*;

class MyObservable extends Observable {
    private int state;

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

class MyObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Received: " + arg);
    }
}

public class Main {
    public static void main(String[] args) {
        MyObservable observable = new MyObservable();
        MyObserver observer = new MyObserver();

observable.addObserver(observer);
        observable.setState(10);
    }
}
```

> ⚠️ 注意：`java.util.Observable` 和 `Observer` 已被弃用，不建议在新项目中使用。

---

## 🔁 三、自定义观察者模式（推荐方式）

我们可以自己实现一个简单的观察者模式，用于理解其原理。

### 1. 定义观察者接口

```java
public interface Observer {
    void update(String message);
}
```

### 2. 定义主题接口

```java
public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String message);
}
```

### 3. 实现具体主题

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

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

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

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

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

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

### 4. 实现具体观察者

```java
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);
    }
}
```

### 5. 使用示例

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

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

subject.registerObserver(observer1);
        subject.registerObserver(observer2);

subject.setState("Hello, Observers!");
    }
}
```

---

## 📌 四、Java 中的事件处理机制（GUI 示例）

在 Java GUI 编程中（如 Swing），事件处理也是基于观察者模式的。

### 示例：按钮点击事件

```java
import javax.swing.*;
import java.awt.event.*;

public class ButtonExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Button Example");
        JButton button = new JButton("Click Me");

button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Button clicked!");
            }
        });

frame.add(button);
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}
```

在这个例子中：
- `JButton` 是 `Subject`
- `ActionListener` 是 `Observer`
- 当按钮被点击时，会触发 `actionPerformed()` 方法

---

## ✅ 总结

| 概念         | 说明 |
|--------------|------|
| 观察者模式   | 一对多的通信机制，适用于事件驱动的系统 |
| Java 事件处理 | 基于观察者模式，如 AWT/Swing 中的事件监听器 |
| 自定义实现   | 可以通过接口和类来模拟观察者模式 |
| 已过时类     | `java.util.Observable` 和 `Observer` 已被弃用 |

---

如果你有特定的场景（比如 GUI、网络通信、数据更新等），我可以帮你进一步定制观察者模式的实现。需要吗？