在Java中，什么叫观察者设计模式(observer design pattern)?

爱被打了一巴掌 2023-10-10 17:26 19阅读 0赞

观察者设计模式（Observer Design Pattern）是一种常用的软件设计模式，属于行为型模式的一种。在该模式中，一个目标对象（Subject）管理所有依赖于它的观察者对象（Observer），并在自身发生改变时主动通知观察者对象，使它们能够自动更新。

在观察者设计模式中，目标对象和观察者对象之间是松耦合的，目标对象并不直接调用观察者对象的方法，而是通过定义一些接口，使得目标对象和观察者对象能够协同工作。

观察者设计模式有很多应用场景，比如在GUI编程中，当一个组件的状态发生改变时，就可以使用该模式。创新性地使用观察者模式可以设计出高效、灵活的系统，同时也可以使代码更加清晰易懂，并且易于维护。

import java.util.*;
    
    interface Observer {
        void update(float temperature, float humidity, float pressure);
    }
    
    class WeatherData {
        private ArrayList<Observer> observers;
        private float temperature;
        private float humidity;
        private float pressure;
        
        public WeatherData() {
            observers = new ArrayList<>();
        }
        
        public void registerObserver(Observer o) {
            observers.add(o);
        }
        
        public void removeObserver(Observer o) {
            int i = observers.indexOf(o);
            if (i >= 0) {
                observers.remove(i);
            }
        }
        
        public void notifyObservers() {
            for (Observer o : observers) {
                o.update(temperature, humidity, pressure);
            }
        }
        
        public void measurementsChanged() {
            notifyObservers();
        }
        
        public void setMeasurements(float temperature, float humidity, float pressure) {
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;
            measurementsChanged();
        }
    }
    
    class CurrentConditionsDisplay implements Observer {
        private float temperature;
        private float humidity;
        
        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");
        }
    }
    
    class StatisticsDisplay implements Observer {
        private float temperatureSum = 0.0f;
        private float temperatureMin = Float.MAX_VALUE;
        private float temperatureMax = Float.MIN_VALUE;
        private int numReadings;
        
        public void update(float temperature, float humidity, float pressure) {
            temperatureSum += temperature;
            numReadings++;
            if (temperature < temperatureMin) {
                temperatureMin = temperature;
            }
            if (temperature > temperatureMax) {
                temperatureMax = temperature;
            }
            display();
        }
        
        public void display() {
            System.out.println("Avg/Max/Min temperature = "
                + (temperatureSum / numReadings) + "/"
                + temperatureMax + "/" + temperatureMin);
        }
    }
    
    public class WeatherStation {
        public static void main(String[] args) {
            WeatherData weatherData = new WeatherData();
            
            CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay();
            StatisticsDisplay statisticsDisplay = new StatisticsDisplay();
            
            weatherData.registerObserver(currentDisplay);
            weatherData.registerObserver(statisticsDisplay);
            
            weatherData.setMeasurements(80, 65, 30.4f);
            weatherData.setMeasurements(82, 70, 29.2f);
            weatherData.setMeasurements(78, 90, 29.2f);
        }
    }

观察者设计模式是Java中的一种行为型设计模式，用于在对象间建立一种一对多的依赖关系，当一个对象的状态发生变化时，它的所有依赖者都会得到通知并自动更新。

在观察者设计模式中，有两种角色：观察者和被观察者。被观察者是一个主题或者一个事件源，它维护一组观察者，并在状态发生改变时通知它们。观察者是依赖于被观察者的对象，它们注册自己到被观察者，以便在状态发生改变时能够接收到通知并进行相应的处理。

Java中的观察者设计模式是通过使用接口和抽象类来实现的。被观察者通常实现一个名为“Observable”的抽象类，而观察者则实现一个名为“Observer”的接口。被观察者在状态发生改变时，调用其“notifyObservers()”方法来通知所有观察者，而观察者则实现“update()”方法来接收并处理通知。

下面是一个简单的Java代码演示观察者设计模式，其中一个WeatherData类是被观察者，而两个观察者CurrentConditionsDisplay和StatisticsDisplay都实现了Observer接口，以便接收WeatherData对象的状态变化通知并作出相应的处理。

输出结果为：

Current conditions: 80.0F degrees and 65.0% humidity
    Avg/Max/Min temperature = 80.0/80.0/80.0
    Current conditions: 82.0F degrees and 70.0% humidity
    Avg/Max/Min temperature = 81.0/82.0/80.0
    Current conditions: 78.0F degrees and 90.0% humidity
    Avg/Max/Min temperature = 80.0/82.0/78

以上代码演示了一个气象站的场景，其中WeatherData类是被观察者，它维护了一个观察者列表observers，并提供了registerObserver、removeObserver、notifyObservers、measurementsChanged和setMeasurements等方法。

在主函数中，创建了两个观察者对象currentDisplay和statisticsDisplay，并将它们注册到WeatherData对象weatherData的观察者列表中。接着调用setMeasurements方法更新气象数据，并观察观察者对象的相应输出。

CurrentConditionsDisplay类是一个观察者，它实现了Observer接口，并在update方法中接收到WeatherData对象的状态变化通知。在这个例子中，CurrentConditionsDisplay类只是简单地输出了当前的温度和湿度。

StatisticsDisplay类也是一个观察者，它在update方法中累加温度数据，并计算平均值、最大值和最小值，并在display方法中输出。

这个例子演示了观察者设计模式的基本思想：被观察者维护一个观察者列表，观察者在被观察者状态变化时接收通知并作出相应的处理。在实际应用中，观察者设计模式可以用于实现事件驱动系统、GUI程序开发、消息队列、通知系统等场景。

观察者设计模式常用于GUI程序开发、事件驱动系统、通知系统等场景。它可以帮助程序员实现松耦合、高内聚的设计，提高系统的可维护性和可扩展性。