《Head First 设计模式》之观察者模式——天气显示

观察者模式（Observer）

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

（出版者Subject+订阅者Observer=观察者模式）

• 特点：定义并维护对象之间的一对多关系

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

• 示例（气象站类图）

三个接口：

 public interface Subject{
     public void registerObserver(Observer o);//注册观察者
     public void removeOberver(Observer o);//删除观察者
     public void notifyObserver();//通知观察者
 }

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

 public interface DisplayElement{
     public void display();
 }

在WeatherData中实现主题接口：

 public class WeatherData implements Subject{
     private ArrayList 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 removeOberver(Observer o){//删除观察者
         int i = observers.indexOf(o);
         if(i >= 0){
             observers.remove(0);
         }
     }
     public void notifyObservers(){
         for(int i = 0; i < observers.size(); i++){ //通知每一个观察者
             Observer observer = (Observer)observers.get(i);
             observer.update(temperature, humidity, pressure);
         }
     }
     public void measurementsChanged(){
         notifyObservers();
     }
     public void setMeasurements(float temp, float hum, float pre){
         this.temperature = temp;
         this.humidity = hum;
         this.pressure = pre;
         measurementsChanged();
     }
 }

实现CurrentConditionDisplay.java

 public class CurrentConditionsDisplay implements Observer, DisplayElement{
     private float temperature;
     private float humidity;
     private Subject weatherData;

     public CurrentConditionsDisplay(Subject weatherData){//构造器需要weatherData对象作为注册之用
         this.weatherData = weatherData;
         weatherData.registerObserver(this);
     }
     public void update(float temp, float humidity, float pressure){
         this.temperature = temp;
         this.humidity = humidity;
         display();
     }
     public void display(){
         //输出
     }
 }

测试程序：

 public class WeatherStation {

         public static void main(String[] args) {
             WeatherData weatherData = new WeatherData();//建立weatherData对象

             CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
             StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
             ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);//将对象传给三个Observer，即add观察者

             weatherData.setMeasurements(80, 65, 30.4f);
             weatherData.setMeasurements(82, 70, 29.2f);
             weatherData.setMeasurements(78, 90, 29.2f);
         }
     }

---

Java内置的观察者模式

　　上述示例实现信息由Subject “推送（push）” 至Observer，使用Java内置的观察者模式可以使用推（push）或拉（pull）的方式传送数据。不同的是WeatherData现在扩展自Observable类，并继承到一些add、delete、notify观察者的方法。

Subject -> java.util.Observable(类)

Observer -> java.util.Observer(接口)

Observable如何送出通知？

　　首先需要利用扩展 java.util.Observable 接口产生“可观察者”类（想要进行通知，则必须调用Observable类的setChanged方法，但是Observable的setChanged方法为protected，故只能使用继承来实现自己的主题对象），然后：

1. 调用setChanged()，标记状态已经改变的事实；
2. 调用notifyObservers()中的一个：notifyObservers() 或 notifyObservers(Object arg)

Observer如何接收通知？

update(Observable o, Object arg)  ：主题Observable作为第一变量，好让观察者知道是哪个主题通知它的。Object arg正是传入notifyObservers(Object arg)的数据对象，如果没有说明则为空。

若想push数据给观察者，可以把数据作数据对象传送给notifyObservers(Object arg)方法。否则，观察者就必须从可观察者对象中pull数据。如何拉数据？

WeatherData.java

 public class WeatherData extends Observable{
     private float temperature;
     private float humidity;
     private float pressure;

     public WeatherData(){ } //无需建立观察者列表ArrayList了
     public void measurementsChanged(){
         setChanged();//状态已经改变
         notifyObservers();//pull
     }
     public void setMeasurements(float temp, float hum, float pre){
         this.temperature = temp;
         this.humidity = hum;
         this.pressure = pre;
         measurementsChanged();
     }
     public float getTemperature(){
         return temperature;
     }
     public float gethumidity(){
         return humidity;
     }
     public float getpressure(){
         return pressure;
     }
 }

CurrentConditionDisplay.java

 public class CurrentConditionsDisplay implements Observer, DisplayElement{
     private float temperature;
     private float humidity;
     Observable observable;

     public CurrentConditionsDisplay(Observable observable){
         this.observable = observable;
         observable.addObserver(this);
     }
     public void update(Observable o, Object arg){
         if(o instanceof WeatherData){
             WeatherData weatherData = (WeatherData)o;
             this.temperature = weatherData.getTemperature();
             this.humidity = weatherData.gethumidity();
             display();
         }
     }
     public void display(){
         //输出
     }
 }

notice：

1. 不想推送的时候，不调用setChanged()方法即可
2. 通知顺序不依赖于注册的顺序（即主题通知观察者的顺序与添加观察者的顺序无关）
3. setChanged()方法的必要性：若无，则温度计读数每十分之一度就会更新，造成WeatherData对象持续不断地通知观察者。若希望温差达到半度时更新，就调用setChanged()。有更多的弹性，更适当地通知观察者。

使用Java自带的观察者模式的缺点：

1. Observable是一个类，而不是一个接口，导致Observable类的扩展性不高，不如自己实现的观察者模式灵活
2. Observable将某些方法保护了起来(setChanged()和clearChanged()为protected)，这意味着除非继承自Observable，否则将有关键的方法不能调用。导致无法通过组合的方式使其它类获得Observable类的功能。违反了设计原则“多用组合，少用继承”。