观察者模式

1.一对多的依赖关系，一变化多感知

2.代码

c++:

//observer c++
#include <iostream>
#include <list>
using namespace std;

//Observer
class Observer{
public:
    virtual void update(float temp,float humidity,float pressure) = 0;
};

//DisplayElement
class DisplayElement{
public:
    virtual void display() = 0;
};

//Subject
class Subject{
public:
    virtual void registerObserver(Observer* o) = 0;
    virtual void removeObserver  (Observer* o) = 0;
    virtual void notifyObservers ()            = 0;
    
};

class WeatherData : public Subject{
public:
    WeatherData(){}
    void registerObserver(Observer* o){
        if(o)
            observers.push_back(o);
    }
    void removeObserver(Observer* o){
        auto it = observers.begin();                   //begin()返回的类型由对象是否为const决定
        while(it != observers.end()){                  //只要执行了erase(it),那么it就会变得无效，
                                                       //那么执行it++就肯定会出错,erase 返回指向删除后位置，要写 it = erase(it);
            if(*it == o)
                it = observers.erase(it);
        }
    }
    void notifyObservers(){
        for(Observer* obs : observers){
            obs->update(temperature,humidity,pressure);
        }
    }
    void measurementsChanged(){
        notifyObservers();
    }
    void setMeasurements(float temperature,float humidity,float pressure){
        this->temperature = temperature;
        this->humidity    = humidity;
        this->pressure    = pressure;
        measurementsChanged();
    }

private:
    list<Observer*> observers;
    float temperature;
    float humidity;
    float pressure;
};

//Current Display
class CurrentConditonDisplay : public Observer,DisplayElement{

public:
    //抽象类型不能用作形参类型，函数返回类型
    CurrentConditonDisplay(WeatherData* weatherData){
        this->weatherData = weatherData;
        weatherData->registerObserver(this);
    }
    void update(float temperature,float humidity,float pressure){
        this->temperature = temperature;
        this->humidity    = humidity;
        display();
    }

    void display(){
        cout<<"\r\nCurrent condition:"<<temperature<<"F degree and "<<humidity<<"%humidity";
    }
    
private:
    float temperature;
    float humidity;
    WeatherData* weatherData;
};

//
int main(){
    WeatherData* weatherData = new WeatherData();        //WeatherData
    CurrentConditonDisplay* currentDisplay = new CurrentConditonDisplay(weatherData);

    weatherData->setMeasurements(80,65,26.3f);
    weatherData->setMeasurements(89,61,30.3f);
    
    //remove
    weatherData->removeObserver(currentDisplay);
    weatherData->setMeasurements(76,67,12.3f);

    return 0;
}

 

 java:

(1)

import java.util.ArrayList;

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

class WeatherData implements Subject{
    private ArrayList<Observer> observers;
    private float temperature;
    private float humidity;
    private float pressure;
    
    public WeatherData(){
        observers = new ArrayList<Observer>();
    }
    //+
    public void registerObserver(Observer o){
        observers.add(o);
    }
    //-
    public void removeObserver(Observer o){
        int i = observers.indexOf(o);
        if(i >= 0)
            observers.remove(i);
    }
    // )))
    public void notifyObservers(){
        for (Observer observer : observers){
            observer.update(temperature,humidity,pressure);
        }
    }
    public void measurementsChanged(){
        notifyObservers();
    }
    public void setMeasurements(float temperature,float humidity,float pressure){
        this.temperature = temperature;
        this.humidity    = humidity;
        this.pressure    = pressure;
        measurementsChanged();
    }
}
//Observer
interface Observer{
    public void update(float temp,float humidity,float pressure);
}

interface DisplayElement{
    public void display();
}

//Current Display
class CurrentConditonDisplay implements Observer,DisplayElement{
    private float temperature;
    private float humidity;
    private Subject weatherData;                           //Subject
    
    public CurrentConditonDisplay(Subject weatherData){
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }
    public void update(float temperature,float humidity,float pressure){
        this.temperature = temperature;
        this.humidity    = humidity;
        display();
    }

    public void display(){
        System.out.println("\r\nCurrent condition:" + temperature + "F degree and " + humidity + "%humidity");
    }
}
public class WeatherStation{
    public static void main(String[] args){
        WeatherData weatherData = new WeatherData();        //WeatherData
        CurrentConditonDisplay currentDisplay = new CurrentConditonDisplay(weatherData);
        //CurrentConditonDisplay currentDisplay2 = new CurrentConditonDisplay(weatherData);
        
        weatherData.setMeasurements(80,65,26.3f);
        weatherData.setMeasurements(89,61,30.3f);
        
        //remove
        weatherData.removeObserver(currentDisplay);
        weatherData.setMeasurements(76,67,12.3f);
    }
}

 

(2)用内置Observable

//use java Observable
//Observable is a class not interface
import java.util.Observable;
import java.util.Observer;

class WeatherData extends Observable{
    private float temperature;
    private float humidity;
    private float pressure;
    
    public WeatherData(){}
    public void measurementsChanged(){
        setChanged();
        notifyObservers();
    }
    public void setMeasuremants(float temperature,float humidity,float pressure){
        this.temperature = temperature;
        this.humidity    = humidity;
        this.pressure    = pressure;
        measurementsChanged();
    }
    public float getTempreature(){
        return temperature;
    }
    public float getHumidity(){
        return humidity;
    }
    public float getPressure(){
        return pressure;
    }
}

//
interface DisplayElement {
    public void display();
}

class CurrentConditionDisplay implements Observer,DisplayElement{
    Observable observable;
    private float temperature;
    private float humidity;
    
    public CurrentConditionDisplay(Observable observable){
        this.observable = observable;
        observable.addObserver(this);
    }
    @Override
    public void update(Observable obs,Object arg){
        if(obs instanceof WeatherData){
            WeatherData weatherData = (WeatherData)obs;
            this.temperature        = weatherData.getTempreature();
            this.humidity           = weatherData.getHumidity();
            display();
        }
    }
    public void display(){
        System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
    }
}
             
public class WeatherStationObable{
    public static void main(String[] args){
        WeatherData weatherData = new WeatherData();
        CurrentConditionDisplay display_1 = new CurrentConditionDisplay(weatherData);
        
        weatherData.setMeasuremants(21,34,65);
        weatherData.setMeasuremants(31,42,75);
    }
}

 

 3.杂注:

(1) 有多个观察者时，不可依赖特定通知顺序

(2)针对接口编程，不针对实现

(3)为对象间松耦合设计而努力

(4)找出变化的方面，和不变的方面分离

    变化：主题的状态，观察者数量，类型；可以改变依赖于主题状态的对象，却不改变主题。

(5)多用组合，少用继承

    将观察者组合进主题中，对象间关系不是继承产生，在运行中组合产生。