如何使用Java中的观察者模式？

该问题的明确答案是推荐使用自定义观察者接口实现观察者模式。1. 虽然Java提供了Observable和Observer，但前者是类且已弃用，缺乏灵活性；2. 现代推荐做法是定义函数式Observer接口，由Subject维护Observer列表并在状态变化时通知所有观察者；3. 可结合Lambda表达式使用，提升代码简洁性与可维护性；4. 对于GUI或JavaBean场景，可选用PropertyChangeListener。因此，新项目应采用自定义观察者接口方案，它类型安全、易于测试且与现代Java特性兼容良好。

The Observer pattern in Java is a behavioral design pattern where an object (called the subject) maintains a list of dependents (called observers) that are notified automatically when the subject changes state. Java provides built-in support for this pattern via the java.util.Observable class and java.util.Observer interface — although they are deprecated since Java 9, understanding them helps grasp the concept. We’ll cover both the legacy approach and the modern, recommended way using custom interfaces or functional programming.

1. Using the Legacy Observable and Observer (Not Recommended)

Even though it's deprecated, here’s how it used to work:

import java.util.Observable;
import java.util.Observer;

// Subject (data source)
class WeatherStation extends Observable {
    private float temperature;

    public void setTemperature(float temperature) {
        this.temperature = temperature;
        setChanged(); // Must call this before notifyObservers
        notifyObservers(temperature); // Send update
    }

    public float getTemperature() {
        return temperature;
    }
}

// Observer (subscriber)
class Display implements Observer {
    private String name;

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

    @Override
    public void update(Observable observable, Object arg) {
        if (observable instanceof WeatherStation) {
            float temp = (Float) arg;
            System.out.println(name   " display: Temperature updated to "   temp   "°C");
        }
    }
}

// Usage
public class ObserverDemo {
    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();
        Display phoneDisplay = new Display("Phone");
        Display tvDisplay = new Display("TV");

        station.addObserver(phoneDisplay);
        station.addObserver(tvDisplay);

        station.setTemperature(25.5f); // Triggers notifications
        station.setTemperature(30.0f);
    }
}

⚠️ Note: Observable is a class, not an interface, so you can't use it with multiple inheritance. That's one reason it was deprecated.

2. Modern Approach: Custom Observer Pattern (Recommended)

Instead of relying on built-in classes, define your own subject-observer contract using interfaces.

Step 1: Define the Observer Interface

@FunctionalInterface
public interface Observer<T> {
    void update(T data);
}

Step 2: Implement the Subject

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

public class WeatherStation {
    private List<Observer<Float>> observers = new ArrayList<>();
    private float temperature;

    public void addObserver(Observer<Float> observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer<Float> observer) {
        observers.remove(observer);
    }

    public void setTemperature(float temperature) {
        this.temperature = temperature;
        notifyObservers();
    }

    private void notifyObservers() {
        for (Observer<Float> observer : observers) {
            observer.update(temperature);
        }
    }

    public float getTemperature() {
        return temperature;
    }
}

Step 3: Use It with Lambda Expressions

public class ModernObserverDemo {
    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();

        // Add observers using lambdas
        station.addObserver(temp -> System.out.println("Phone Display: "   temp   "°C"));
        station.addObserver(temp -> System.out.println("TV Display: "   temp   "°C"));
        station.addObserver(temp -> {
            if (temp > 28) {
                System.out.println("Alert: High temperature detected!");
            }
        });

        // Change state
        station.setTemperature(25.0f);
        station.setTemperature(29.5f);
    }
}

Output:

Phone Display: 25.0°C
TV Display: 25.0°C
Phone Display: 29.5°C
TV Display: 29.5°C
Alert: High temperature detected!

This approach is:

• More flexible (uses interfaces, not concrete classes)
• Supports lambda expressions
• Easier to test and extend
• Not tied to deprecated APIs

3. Alternative: Using PropertyChangeListener (For GUI or Bean-like Objects)

Java also has java.beans.PropertyChangeListener, which is still not deprecated and useful in certain contexts (like Swing or POJOs with property change events).

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

public class SmartThermostat {
    private final PropertyChangeSupport support = new PropertyChangeSupport(this);
    private int targetTemp;

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

    public void setTargetTemp(int newTemp) {
        int old = this.targetTemp;
        this.targetTemp = newTemp;
        support.firePropertyChange("targetTemp", old, newTemp);
    }
}

Useful when you want to track which property changed and its old/new values.

Summary

For new projects, go with a custom observer interface — it's simple, type-safe, and works well with lambdas.

Basically, just:

• Define an Observer<t></t> interface
• Maintain a list of listeners in your subject
• Notify them on state change

That’s the Observer pattern done right in modern Java.

以上是如何使用Java中的观察者模式？的详细内容。更多信息请关注PHP中文网其他相关文章！