观察者模式读书笔记

一般观察者模式用在一对多的关系中，当一个对象发生改变时，依赖这个对象的其他对象就要自动做出改变。

气象站例子

这个气象站系统中包含三个部分，气象站代表获取实际气象数据的物理装置，WeatherData对象可以追踪来自气象站的数据，并更新布告板，布告板是展示给用户看的。

WeatherData对象知道如何跟物理气象站联系，拿到相应数据之后，会更新布告板，

如果我们写代码的话，可能会写成如下样子：

public class WeatherData {

    public void measurementsChanged(){
        //从气象站获得相关温度、湿度、气压等信息
        float temp = getTemperature();
        float humidity = getHumidity();
        float pressure = getPressure();

        //更新三个布告板的相关天气信息
        currentConditionDisplay.update(temp, humidity, pressure);
        statisticDisplay.update(temp, humidity, pressure);
        forecastDisplay.update(temp, humidity, pressure);

    }
}

那这样做有什么不好的地方呢？
1、三个update方法看起来应该像个统一的接口，所以要封装起来
2、三个update方法针对实现编程，会导致我们以后再增加或者删除布告板时必须修改程序。

认识观察者模式

举个例子，我们向某家报社订阅报纸，只要他们有新闻出版，就会给你送新的报纸来。如果我们取消订阅的话，报社就不会给我们送新的报纸过来。会有很多订阅者都向这个报社订阅报纸，而且这些订阅者都可以取消订阅关系。

出版者+订阅者= 观察者模式

定义观察者模式

观察者定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖都会收到通知并自动更新。

优点

1、关于观察者的一切，主题只知道贯彻着实现了某个接口（也就是Observer接口）。主题不需要知道观察者的具体类是谁，做了些什么或者其他什么细节。

2、任何时候我们都可以增加新的观察者，因为主题唯一依赖的东西是一个实现Observer接口的对象列表，所以我们可以随时增加和删除观察者。

3、有新的类型的观察者出现的时候，我们不需要改变主题的代码，所要做的就是在新的类里面实现观察者的接口。

4、可以独立复用观察者这主题。

气象站代码

Subject.java

public interface Subject {
    public void registerObserver(Observer observer);
    public void removeObserver(Observer o);
    public void notifyObservers();
}

Observer.java

public interface Observer {
    public void update(float temp, float humidity, float pressure);
}

DisplayElement.java //用来展示数据

public interface DisplayElement {
    public void display();
}

WeatherData.java //主题

import java.util.ArrayList;

public class WeatherData implements Subject{

    private float temprature;
    private float humidity;
    private float pressure;
    private ArrayList observers;

    public WeatherData(){
        observers = new ArrayList();
    }

    public void measurementsChanged(){//更新观察者
      notifyObservers();

    }

    public void setMeasurements(float temprature, float humidity, float pressure){
        this.temprature = temprature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }

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

    @Override
    public void removeObserver(Observer o) {
        int i = observers.indexOf(o);
        if (i >= 0){
            observers.remove(o);
        }
    }

    @Override
    public void notifyObservers() {
        for (int i = 0; i < observers.size(); i++){
            Observer observer = (Observer) observers.get(i);
            observer.update(temprature, humidity, pressure);
        }
    }
}

CurrentConditionsDisplay.java // 观察者

public class CurrentConditionsDisplay implements Observer, DisplayElement {

    public CurrentConditionsDisplay(Subject weatherData){
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    private float temperature;
    private float humidity;
    private float pressure;

    private Subject weatherData;

    @Override
    public void display() {
        System.out.println("Current conditions: +" + temperature + " F degrees and" + humidity +"% humidity");
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        this.temperature = temp;
        this.humidity = humidity;
        this.pressure = pressure;
        display();
    }
}

WeatherStation.java //测试方法

public class WeatherStation {

    public static void main(String [] args){
        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(weatherData);
        weatherData.setMeasurements(80, 65, 30.4f);
    }
}

java中的实现方法

代码中我们的主题将自己的主题主动推送给观察者，当然还有另外一种方式，就是观察者根据自己的需求拉取主题的数据。 两种方式都有各自的优缺点。 Java内置的观察者模式同时支持者两种。

Java中相对于我们刚才的实现有几点不同，
1、java中的主题叫Observable，观察者叫Observer。
2、Observable并不是一个接口，而是一个类。这样会有几个问题，因为Observable是个类，所以你必须设计一个类来继承他。如果某类想同时具有Observable类和另一个超类的行为，就会陷入两难，毕竟java不支持多继承。