设计模式-观察者模式(下)<转>

观察者模式在Java中有两种实现方式，上文是一种方式，这种方式是自己写代码实现。

另一种方式是使用Java内置的观察者模式来实现。

 

相关的接口和类如下：

java.util.Observable   主题（可观察者）------class
java.util.Observer       观察者                     -------interface

 

 

相关的API如下：

1、java.util.Observable

Observable() 
          构造一个带有零个观察者的 Observable。 
方法摘要 
void addObserver(Observer o) 
          如果观察者与集合中已有的观察者不同，则向对象的观察者集合中添加此观察者。 
protected  void clearChanged() 
          指示对象不再改变，或者它已对其所有的观察者通知了最近的改变，所以 hasChanged 方法将返回 false。 
 int countObservers() 
          返回 Observable 对象的观察者数目。 
 void deleteObserver(Observer o) 
          从对象的观察者集合中删除某个观察者。 
 void deleteObservers() 
          清除观察者列表，使此对象不再有任何观察者。 
 boolean hasChanged() 
          测试对象是否改变。 
 void notifyObservers() 
          如果 hasChanged 方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来指示此对象不再改变。 
 void notifyObservers(Object arg) 
          如果 hasChanged 方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来指示此对象不再改变。 
protected  void setChanged() 
          标记此 Observable 对象为已改变的对象；现在 hasChanged 方法将返回 true。

 

2、java.util.Observer
void update(Observable o, Object arg) 
          只要改变了 observable 对象就调用此方法。

 

观察API可以发现，java.util.Observable已经对观察者进行管理了，不再需要主题追踪每个观察者了。

 

下面通过Java的内置的观察者模式来重写上个天气应用，部分类代码如下：

import java.util.Observable; 

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

        public WeatherData() { 
        } 

        /** 
         * 测量值改变了 
         */ 
        public void measurementsChanged() { 
                setChanged();             //设定改变了 
                notifyObservers();    //通知所有的观察者 
        } 

        /** 
         * 重新设定了测量值 
         */ 
        public void setMeasurements(float temperature, float humidity, float pressure) { 
                this.temperature = temperature; 
                this.humidity = humidity; 
                this.pressure = pressure; 
                measurementsChanged(); 
        } 

        public float getTemperature() { 
                return temperature; 
        } 

        public float getHumidity() { 
                return humidity; 
        } 

        public float getPressure() { 
                return pressure; 
        } 
}

 

public interface DisplayElement { 
        public void display(); 
}

 

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

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

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

        public void update(Observable obs, Object arg) { 
                if (obs instanceof WeatherData) { 
                        WeatherData weatherData = (WeatherData) obs; 
                        this.temperature = weatherData.getTemperature(); 
                        this.humidity = weatherData.getHumidity(); 
                        display(); 
                } 
        } 

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

 

看上面的代码，

java.util.Observable不是接口，是类，如果一个类想具有另一个超类的功能，同时还想拥有Observable行为，就陷入两难地步。

 

实际上，Java内部使用观察者模式也很多，GUI的事件就是典型的观察者模式。

 

本文出自 “熔 岩” 博客，请务必保留此出处http://lavasoft.blog.51cto.com/62575/201633