观察者模式

      在C#中有按钮的事件，在java swing中也有同样的事件，还接触过Android，同样也有这样的事件。我们想象一下，这些都用什么共同的特点？以c#为例，我们双击按钮就会出现按 钮事件的执行方法。在java中，自己也要添加监听事件，就收一个实现了ActionListener借口的类、有没有发现一点规律？就是当你触发某个东西时，会执行某个方法（操作）。Button类会监听按钮按下的事件，这个事件发生后会执行其他类中的代码！

　　想象一个下我们现实生活中的例子，你可以订阅报纸，每当有新闻发生（我们可以简单的理解每一期就是一个事件发生），你就会收到新的报纸。报社跟你之间没有其他的任何其他关系。

　　现有一个模式，我们有气象台给的WeatherData数据，需要我们将之显示到用户的设备上（目前状况、气象统计、天气预报三个布告板）。这是不是类似于订阅报纸的过程，当气象站有新的气象数据时，它会通知我们及时更新布告板。

                

　　那么，我们现在有什么呢？

　　1、WeatherData类具有gettter方法，可以取得三个测量值。

　　2、当新的数据准备好时，通知显示装置的方法（measurementChanged）会被调用。

　　3、收到新的数据，显示装置应立刻更新显示。

　　4、系统必须可扩展，以后随时增加或删除新的布告板。

那现在有一种情况，

public void measurementChanged(){
     currentConditionDisplay.update(temp, humidity, pressure);
     .........
     .........             
}    

get方法省略没写，只写了一个布告板的update方法。这虽然能实现需要的功能，但是想象一下，扩展性好吗？如果增加一个布告板，是不是还要在WeatherData类中改变代码？这明显是不合理的，每一个布告板都对应着一个这样的调用。回忆一下策略模式，这里明显不是面向接口编程，而是面向实现编程。想到解决的办法了吗？下面我们要用观察者模式来解决这个问题。

　　那现在，我们正式的引入观察者模式。严格的定义：对象之间一对多依赖，这样一来，当每一个对象改变状态时，他的依赖着都会就收通知并自动更新。我们看看图例：

        

　　观察者对象都订阅了某个事件，当事件发生时，主题对象就通知观察这对象。图中鸭子对象没有订阅，所以得不到通知。这时候设计就清楚了，为了设计的程序通用（以后增加或者减少观察者），我们需要面向接口编程。设计主题、观察者、显示（每个观察者都需要显示，不变的地方拿出来：见策略模式）为接口，WeatherData实现主题接口，各个布告板实现观察者和显示接口。这样脉络就清楚了，各个接口，类包含的功能见下面的图。

                

　　这里只简单的画了两个观察者，还有其他的观察者，如：气象统计，还有开发人员自己看的布告板。好了，图里面就不画了。奥，对了有没有法相主题和观察者之间的松耦合呢？这是OO设计原则非常重要的一点。设计原则：为了交互对象之间的松耦合设计而努力。

下面看我们实现的观察者模式的代码：

Subject接口实现：

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

Observer接口的实现：

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

DisplayElement接口的实现：

public interface DisplayElement {
    public void display();
}

上面三个都是接口，我们提倡面向接口编程，可以保证代码的可拓展性。下面我们来看主题对象WeatherData（继承Subject接口）的代码：

public class WeatherData implements Subject{
    private ArrayList observers;
    private float temperature;
    private float humidity;
    private float pressure;
    public WeatherData(){
        observers = new ArrayList();
    }
    @Override
    public void registerObserver(Observer o){
        observers.add(o);
    }
    @Override
    public void removeObserver(Observer o){
        int i = observers.indexOf(o);
        if(i >= 0){
            observers.remove(i);
        }
    }
    @Override
    public void notifyObservers(){
        for(int i = 0; i < observers.size(); i++){
            Observer observer = (Observer)observers.get(i);
            observer.update(temperature, humidity, pressure);
        }
    }
    public void measurementChanged(){
        notifyObservers();
    }
    public void setMeasurements(float temperature, float humidity, float pressure){
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementChanged();
    }
}

下面各个布告板实现Observer和DispayElement接口：

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

    public CurrentConditionsDisplay(Subject weatherData) {
        // TODO Auto-generated constructor stub
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }
    
    @Override
    public void display() {
        // TODO Auto-generated method stub
        System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
    }

    @Override
    public void update(float temp, float humidity, float presser) {
        // TODO Auto-generated method stub
        this.temperature = temp;
        this.humidity = humidity;
        display();
    }
}


public class StatisticsDisplay implements Observer, DisplayElement {
    private float maxTemp = 0.0f;
    private float minTemp = 200;
    private float tempSum= 0.0f;
    private int numReadings;
    private WeatherData weatherData;

    public StatisticsDisplay(WeatherData weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    public void update(float temp, float humidity, float pressure) {
        tempSum += temp;
        numReadings++;

        if (temp > maxTemp) {
            maxTemp = temp;
        }
 
        if (temp < minTemp) {
            minTemp = temp;
        }

        display();
    }

    public void display() {
        System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings)
            + "/" + maxTemp + "/" + minTemp);
    }
}


public class ForecastDisplay implements Observer, DisplayElement {
    private float currentPressure = 29.92f;  
    private float lastPressure;
    private WeatherData weatherData;

    public ForecastDisplay(WeatherData weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    public void update(float temp, float humidity, float pressure) {
        lastPressure = currentPressure;
        currentPressure = pressure;

        display();
    }

    public void display() {
        System.out.print("Forecast: ");
        if (currentPressure > lastPressure) {
            System.out.println("Improving weather on the way!");
        } else if (currentPressure == lastPressure) {
            System.out.println("More of the same");
        } else if (currentPressure < lastPressure) {
            System.out.println("Watch out for cooler, rainy weather");
        }
    }
}


public class HeatIndexDisplay implements Observer, DisplayElement  {
    float heatIndex = 0.0f;
    private WeatherData weatherData;

    public HeatIndexDisplay(WeatherData weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    public void update(float t, float rh, float pressure) {
        heatIndex = computeHeatIndex(t, rh);
        display();
    }
    
    private float computeHeatIndex(float t, float rh) {
        float index = (float)((16.923 + (0.185212 * t) + (5.37941 * rh) - (0.100254 * t * rh) 
            + (0.00941695 * (t * t)) + (0.00728898 * (rh * rh)) 
            + (0.000345372 * (t * t * rh)) - (0.000814971 * (t * rh * rh)) +
            (0.0000102102 * (t * t * rh * rh)) - (0.000038646 * (t * t * t)) + (0.0000291583 * 
            (rh * rh * rh)) + (0.00000142721 * (t * t * t * rh)) + 
            (0.000000197483 * (t * rh * rh * rh)) - (0.0000000218429 * (t * t * t * rh * rh)) +
            0.000000000843296 * (t * t * rh * rh * rh)) -
            (0.0000000000481975 * (t * t * t * rh * rh * rh)));
        return index;
    }

    public void display() {
        System.out.println("Heat index is " + heatIndex);
    }
}

再来启动测试程序：

public class WeatherStationHeatIndex {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
        ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);
        HeatIndexDisplay heatIndexDisplay = new HeatIndexDisplay(weatherData);

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

　　相信代码可以看的更清楚，上面有哪里表达不清楚的，看了代码相信没有什么问题了。

　　本文作为方便自己复习而写，当然我也尽了最大努力写清楚，以方便同时其他人也能看懂，在自己学习的同时最好能够帮助到别人。当然，由于水平不足，肯定有什么错误或者不足的地方，希望大家指正批评。