head first 设计模式总结（二）观察者模式

设计原则

                为交互对象之间的松耦合设计而努力

定义

       在对象之间建立一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象都会收到通知，并自动更新

举例

       公司要设计一个气象站监测系统，该系统建立在weatherData（被观察者）对象之上，并且包括三种不同的布告板（观察者），布告板上的数据必须实时更新，而且，需要提供一套API，使得其它开发人员可以写出不同的布告板。

观察者模式结构图如下：

一个主题(Subject)包括多个观察者(Observer)，调用registerObserver方法添加观察者，removeObserver方法删除观察者，当状态有变化时调用nofifyObservers通知观察者，在notifyObservers方法中遍历所有的Observer并调用其update方法。
 根据观察者模式设计我们的结构如下：

具体代码如下：

1、Subject

public interface Subject
{
    public void registerObserver(Observer observer);

    public void removeObserver(Observer observer);

    public void notifyObservers();
}

2、WeatherData

public class WeatherData implements Subject
{
    private List<Observer> observers;

    private float temperature;

    private float humidity;

    public WeatherData()
    {
        this.observers = new ArrayList<Observer>();
    }

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

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

    @Override
    public void notifyObservers()
    {
        for (Observer o : observers)
        {
            o.update(this.temperature, this.humidity);
        }
    }

    public void measurementsChanged(float temperature, float humidity)
    {
        this.temperature = temperature;
        this.humidity = humidity;
        notifyObservers();
    }

}

3、Observer

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

4、DisplayElement

public interface DisplayElement
{
    public void display();
}

5、ConcreteObserver

public class ConcreteObserver implements Observer, DisplayElement
{
    private float temperature;

    private float humidity;

    private Subject subject;

    public ConcreteObserver(Subject subject)
    {
        this.subject = subject;
    }
    
    @Override
    public void update(float temperature, float humidity)
    {
        this.temperature = temperature;
        this.humidity = humidity;
        display();
    }

    @Override
    public void display()
    {
        System.out.println("temperature:" + temperature + ", humidity:" + humidity);
    }

}

在此设计中Observer保存的Subject引用并没有起到任何作用，但一般设计中都会存放这样一个引用，以方便当观察者想取消观察时调用其removeObserver方法，另外也可以在Observer中直接保存Subject接口的具体实现(WeatherData)，同时WeatherDate中提供一些get方法，当调用Observer的update方法时就不用传任何参数，Observer可以根据自己的需要来取数据，这样一来，以后在Subject中加入其它状态时，就不用修改update方法。如果不这样做，也可以将所有的状态数据封闭成一个对象，update方法中直接传这个对象，方便以后加状态时，不用修改update方法。

java内置了观察者模式，即继承Observable类和实现Observer接口

具体实现如下：

1、WeatherData

import java.util.Observable;

public class WeatherData extends Observable
{
    private float temperature;

    private float humidity;

    public void measurementsChanged(float temperature, float humidity)
    {
        this.temperature = temperature;
        this.humidity = humidity;
        setChanged();
        notifyObservers();
    }

    public float getTemperature()
    {
        return temperature;
    }

    public float getHumidity()
    {
        return humidity;
    }

}

2、ConcreteObserver

public class ConcreteObserver implements Observer, DisplayElement
{
    private float temperature;

    private float humidity;

    private Observable observable;

    public ConcreteObserver(Observable observable)
    {
        this.observable = observable;
        observable.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg)
    {
        if(o instanceof WeatherData){
            WeatherData wd = (WeatherData) o;
            this.humidity = wd.getHumidity();
            this.temperature = wd.getTemperature();
            display();
        }
    }

    @Override
    public void display()
    {
        System.out.println("temperature:" + temperature + ", humidity:" + humidity);
    }

}

使用java内置的Observable类有一些缺点

（1）Observable是一个类，必须设计类来继承它，如果所设计的类必须继承其它的类，则会产生冲突，另外，没有接口，自己无法重写Observalbe类与java内置的其它观察者模式类搭配使用

（2）Observable将一些方法保护起来了，如setChanged()，除非用继承，否则无法创建Observable类并组合到自己的对象中来，这违反了多用组合少用继承的原则