[关闭]
@DevWiki 2015-07-02T21:15:04.000000Z 字数 15154 阅读 1019

Java设计模式---观察者模式

设计模式

更多内容详见:Java设计模式学习笔记

故事概要

概要

故事要从一个业务需求开始:

天气监测站目前可以监测到气温,气压,湿度三种指标,有一个WeatherData类,当前面的三个数据发生变化时,就会调用WeatherData类的setWeatherData()方法,改变天气数据.

现在要求:需要有两个显示装置显示现在的状态和平均状态.当监测的数据有变化时,就更新显示.而且需要提供给第三方的人员可调用这些数据以设置想要的显示装置.如下图:

业务需求图

下面是给出的WeatherData类:

  1. public class WeatherData {
  3.     private float temp;
  4.     private float humidity;
  5.     private float pressure;
  7.     public WeatherData(){}
  9.     public void setWeatherData(float temp, float humidity, float pressure){
  10.         this.temp = temp;
  11.         this.humidity = humidity;
  12.         this.pressure = pressure;
  13.         dataChanged();
  14.     }
  16.     public void dataChanged(){
  17.         //数据发生变化则调用此方法,可在此处填写你的代码
  18.     }
  20.     public float getTemp() {
  21.         return temp;
  22.     }
  24.     public float getHumidity() {
  25.         return humidity;
  26.     }
  28.     public float getPressure() {
  29.         return pressure;
  30.     }
  31. }

提取已知条件

目前已知的条件:
1. WeatherData具有三个getter方法,可获取到温度,气压和湿度三个数值.
2. 当监测到新的数据时就会调用dataChanged()方法.
3. 需要实现两个显示器,一个显示当前状况(CurrentConditionsDisplay),一个显示平均状态(AvgStateDisplay).
4. 系统要能扩展,第三方可以组合实现显示器.

简单实现

根据以上前提,可以用以下方法实现:

  1. public void dataChanged(){
  2.     //数据发生变化则调用此方法,可在此处填写你的代码
  3.     currentConditionsDisplay.update(temp, humidity, pressure);
  4.     avgStateDisplay.update(temp, humidity, pressure);
  5. }

其中,CurrentConditionsDisplay和AvgStateDisplay如下:

  1. //显示当前状态
  2. public class CurrentConditionsDisplay{
  4.     private float temp;
  5.     private float humidity;
  6.     private float pressure;
  8.     public void update(float temp, float humidity, float pressure) {
  9.         this.temp = temp;
  10.         this.humidity = humidity;
  11.         this.pressure = pressure;
  12.         display();
  13.     }
  15.     public void display(){
  16.         //显示当前状态
  17.         String displayData = "CurrentConditions[temp=" + temp + ", humidity=" + humidity + 
  18.             ", pressure="+ pressure + "]";
  19.         System.out.println(displayData);
  20.     }
  21. }
  24. //显示平均状态
  25. public class AvgStateDisplay {
  27.     public void display() {
  28.         System.out.println(getShowInfo());
  29.     }
  31.     private String getShowInfo(){
  32.         StringBuilder displayData = new StringBuilder();
  33.         if (tempList.size() == 0) {
  34.             displayData.append("暂时没有数据...");
  35.             return displayData.toString();
  36.         }
  38.         float tempAve = calculatorAve(tempList);
  39.         displayData.append("平均气温:" + tempAve);
  41.         float humidityAve = calculatorAve(humidityList);
  42.         displayData.append(",平均湿度:" + humidityAve);
  44.         float pressureAve = calculatorAve(pressureList);
  45.         displayData.append(",平均压强:" + pressureAve);
  47.         return displayData.toString();
  48.     }
  50.     private float calculatorAve(List<Float> dataList){
  51.         float sum = 0F;
  52.         for (Float float1 : dataList) {
  53.             sum = sum + float1;
  54.         }
  55.         float ave = sum/dataList.size();
  56.         return ave;
  57.     }
  59.     private List<Float> tempList;
  60.     private float temp;
  61.     private List<Float> humidityList;
  62.     private float humidity;
  63.     private List<Float> pressureList;
  64.     private float pressure;
  66.     public void update(float temp, float humidity, float pressure) {
  67.         this.temp = temp;
  68.         this.humidity = humidity;
  69.         this.pressure = pressure;
  70.         if (tempList == null) {
  71.             tempList = new ArrayList<Float>();
  72.         }
  73.         tempList.add(temp);
  75.         if (humidityList == null) {
  76.             humidityList = new ArrayList<Float>();
  77.         }
  78.         humidityList.add(humidity);
  80.         if (pressureList == null) {
  81.             pressureList = new ArrayList<Float>();
  82.         }
  83.         pressureList.add(pressure);
  84.         display();
  85.     }
  86. }

这不就实现了刚才的功能:
1. 能显示当前状态
2. 能显示平均状态
3. 第三方可以通过WeatherData的dataChanged()方法获取数据,自己任意显示.

有没有问题?

上一篇文章学习了Java设计的原则:

封装变化和面向接口编程

上述的实现中:

  1. public void dataChanged(){
  2.     //数据发生变化则调用此方法,可在此处填写你的代码
  3.     currentConditionsDisplay.update(temp, humidity, pressure);
  4.     avgStateDisplay.update(temp, humidity, pressure);
  5. }

这个里面的3,4两句是变化的,这部分没有封装.而且应该面向接口编程而不是面向具体的类编程,如果增加第三方的显示器,只能修改此处添加代码

认识观察者模式

从订阅报纸开始

报纸的订阅过程一般如下:

观察者模式就和上面的订报纸差不多:

出版者改称为“主题”（Subject），订阅者改称为“观察者”（Observer）

观察者模式

观察者模式

观察者模式

观察者模式

观察者模式

定义观察者模式

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

观察者模式

观察者模式的类图

观察者模式类图

从以上类图可以看出,观察者模式的是遵守针对接口编程原则的.

手动实现气象站的观察者模式

1.观察者接口

观察者是一个接口:Observer

  1. public interface Observer {
  2.     //用于更新的方法
  3.     void update(float temp, float humidity, float pressure);
  4. }

2.观察对象接口

贯彻对象接口有三个作用:
1. 观察者注册为观察者
2. 观察者解除注册
3. 数据更新时通知观察者

  1. public interface Subject {
  3.     //注册为观察者
  4.     void registerObserver(Observer observer);
  6.     //解除注册
  7.     void unregisterObserver(Observer observer);
  9.     //通知观察者
  10.     void notifyObserver();
  12. }

3.新的WeatherData类

其中的setter是给气象站设置数据使用.getter是给第三方获取数据使用

  1. public class WeatherData implements Subject{
  3.     private float temp;
  4.     private float humidity;
  5.     private float pressure;
  6.     private List<Observer> observerList;
  8.     public WeatherData(){
  9.         observerList = new ArrayList<Observer>();
  10.     }
  12.     public void setWeatherData(float temp, float humidity, float pressure){
  13.         this.temp = temp;
  14.         this.humidity = humidity;
  15.         this.pressure = pressure;
  16.         dataChanged();
  17.     }
  19.     public void dataChanged(){
  20.         notifyObserver();
  21.     }
  23.     public void registerObserver(Observer observer) {
  24.         observerList.add(observer);
  25.     }
  27.     public void unregisterObserver(Observer observer) {
  28.         int index = observerList.indexOf(observer);
  29.         if (index >= 0) {
  30.             observerList.remove(observer);
  31.         }
  32.     }
  34.     public void notifyObserver() {
  35.         for (Observer observer : observerList) {
  36.             observer.update(temp, humidity, pressure);
  37.         }
  38.     }
  40.     public float getTemp() {
  41.         return temp;
  42.     }
  44.     public void setTemp(float temp) {
  45.         this.temp = temp;
  46.     }
  48.     public float getHumidity() {
  49.         return humidity;
  50.     }
  52.     public void setHumidity(float humidity) {
  53.         this.humidity = humidity;
  54.     }
  56.     public float getPressure() {
  57.         return pressure;
  58.     }
  60.     public void setPressure(float pressure) {
  61.         this.pressure = pressure;
  62.     }
  63. }

4.显示器接口

显示器接口是用来实现各种显示器的

  1. public interface DisplayElement {
  3.     void display();
  4. }

5.显示器的实现类:CurrentConditionsDisplay和AvgStateDisplay类

CurrentConditionsDisplay:当前状态显示器
AvgStateDisplay:平均状态显示器

  1. public class CurrentConditionsDisplay implements Observer, DisplayElement {
  3.     private WeatherData weatherData;
  5.     public CurrentConditionsDisplay(WeatherData weatherData){
  6.         this.weatherData = weatherData;
  7.         weatherData.registerObserver(this);
  8.     }
  10.     public void unregister(){
  11.         weatherData.unregisterObserver(this);
  12.     }
  14.     public void display() {
  15.         String displayData = "CurrentConditions[temp=" + temp + ", humidity=" + humidity + ", pressure="
  16.                 + pressure + "]";
  17.         System.out.println(displayData);
  18.     }
  20.     private float temp;
  21.     private float humidity;
  22.     private float pressure;
  23.     public void update(float temp, float humidity, float pressure) {
  24.         this.temp = temp;
  25.         this.humidity = humidity;
  26.         this.pressure = pressure;
  27.         display();
  28.     }
  29. }
  31. //---------------------------------------------------------------//
  33. public class AvgStateDisplay implements Observer, DisplayElement{
  35.     private WeatherData weatherData;
  36.     public AvgStateDisplay(WeatherData weatherData){
  37.         this.weatherData = weatherData;
  38.         weatherData.registerObserver(this);
  39.     }
  41.     public void unregister(){
  42.         weatherData.unregisterObserver(this);
  43.     }
  45.     public void display() {
  46.         System.out.println(getShowInfo());
  47.     }
  49.     private String getShowInfo(){
  50.         StringBuilder displayData = new StringBuilder();
  51.         if (tempList.size() == 0) {
  52.             displayData.append("暂时没有数据...");
  53.             return displayData.toString();
  54.         }
  56.         float tempAve = calculatorAve(tempList);
  57.         displayData.append("平均气温:" + tempAve);
  59.         float humidityAve = calculatorAve(humidityList);
  60.         displayData.append(",平均湿度:" + humidityAve);
  62.         float pressureAve = calculatorAve(pressureList);
  63.         displayData.append(",平均压强:" + pressureAve);
  65.         return displayData.toString();
  66.     }
  68.     private float calculatorAve(List<Float> dataList){
  69.         float sum = 0F;
  70.         for (Float float1 : dataList) {
  71.             sum = sum + float1;
  72.         }
  73.         float ave = sum/dataList.size();
  74.         return ave;
  75.     }
  77.     private List<Float> tempList;
  78.     private float temp;
  79.     private List<Float> humidityList;
  80.     private float humidity;
  81.     private List<Float> pressureList;
  82.     private float pressure;
  83.     public void update(float temp, float humidity, float pressure) {
  84.         this.temp = temp;
  85.         this.humidity = humidity;
  86.         this.pressure = pressure;
  87.         if (tempList == null) {
  88.             tempList = new ArrayList<Float>();
  89.         }
  90.         tempList.add(temp);
  92.         if (humidityList == null) {
  93.             humidityList = new ArrayList<Float>();
  94.         }
  95.         humidityList.add(humidity);
  97.         if (pressureList == null) {
  98.             pressureList = new ArrayList<Float>();
  99.         }
  100.         pressureList.add(pressure);
  101.         display();
  102.     }
  103. }

6.测试

测试气象站数据变化时能否通知当前状态显示器和平均状态显示器更新数据

  1. public class WeatherStation {
  3.     public static void main(String[] args) {
  4.         WeatherData weatherData = new WeatherData();
  6.         CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
  7.         AvgStateDisplay stateDisplay = new AvgStateDisplay(weatherData);
  9.         weatherData.setWeatherData(25.0F, 80F, 1.01F);
  10.         try {
  11.             Thread.sleep(3000);
  12.         } catch (InterruptedException e) {
  13.             e.printStackTrace();
  14.         }
  15.         weatherData.setWeatherData(26.2F, 76F, 1.02F);
  16.         try {
  17.             Thread.sleep(3000);
  18.         } catch (InterruptedException e) {
  19.             e.printStackTrace();
  20.         }
  21.         weatherData.setWeatherData(27.8F, 70F, 1.01F);
  22.     }
  23. }

输出结果为:

  1. CurrentConditions[temp=25.0, humidity=80.0, pressure=1.01]
  2. 平均气温:25.0,平均湿度:80.0,平均压强:1.01
  3. CurrentConditions[temp=26.2, humidity=76.0, pressure=1.02]
  4. 平均气温:25.6,平均湿度:78.0,平均压强:1.015
  5. CurrentConditions[temp=27.8, humidity=70.0, pressure=1.01]
  6. 平均气温:26.333334,平均湿度:75.333336,平均压强:1.0133333

7.增加酷热指数的显示器:HeatIndexDisplay

  1. public class HeatIndexDisplay implements Observer, DisplayElement{
  3.     private WeatherData weatherData;
  4.     public HeatIndexDisplay(WeatherData weatherData){
  5.         this.weatherData = weatherData;
  6.         weatherData.registerObserver(this);
  7.     }
  9.     public void unregister(){
  10.         weatherData.unregisterObserver(this);
  11.     }
  13.     @Override
  14.     public void display() {
  15.         System.out.println("当前酷热指数:" + getHeatIndex());
  16.     }
  18.     private float getHeatIndex(){
  19.         float heatIndex = 0F;
  20.         //此处酷热指数计算公式不正确,是随意写的
  21.         heatIndex = (float) (temp*Math.PI + humidity*Math.E + pressure*1.01315)/5;
  22.         return heatIndex;
  23.     }
  25.     private float temp;
  26.     private float humidity;
  27.     private float pressure;
  28.     @Override
  29.     public void update(float temp, float humidity, float pressure) {
  30.         this.temp = temp;
  31.         this.humidity = humidity;
  32.         this.pressure = pressure;
  33.         display();
  34.     }
  35. }

8.测试第三方的显示器

  1. public class WeatherStation {
  3.     public static void main(String[] args) {
  4.         WeatherData weatherData = new WeatherData();
  6.         CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
  7.         AvgStateDisplay stateDisplay = new AvgStateDisplay(weatherData);
  8.         HeatIndexDisplay heatIndexDisplay = new HeatIndexDisplay(weatherData);
  10.         weatherData.setWeatherData(25.0F, 80F, 1.01F);
  11.         try {
  12.             Thread.sleep(3000);
  13.         } catch (InterruptedException e) {
  14.             e.printStackTrace();
  15.         }
  16.         weatherData.setWeatherData(26.2F, 76F, 1.02F);
  17.         try {
  18.             Thread.sleep(3000);
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  22.         weatherData.setWeatherData(27.8F, 70F, 1.01F);
  23.     }
  24. }

测试结果如下:

  1. CurrentConditions[temp=25.0, humidity=80.0, pressure=1.01]
  2. 平均气温:25.0,平均湿度:80.0,平均压强:1.01
  3. 当前酷热指数:59.40513
  4. CurrentConditions[temp=26.2, humidity=76.0, pressure=1.02]
  5. 平均气温:25.6,平均湿度:78.0,平均压强:1.015
  6. 当前酷热指数:57.98651
  7. CurrentConditions[temp=27.8, humidity=70.0, pressure=1.01]
  8. 平均气温:26.333334,平均湿度:75.333336,平均压强:1.0133333
  9. 当前酷热指数:55.727856

小结

经过以上测试,我们使用了观察者模式实现了:
1. 气象站测试到数据-->发布数据变更--->更新各个不同类型的显示器.
2. 实现了当前状况的显示和平均状态的显示
3. 开发者可是自行实现多种形式的显示器

Java内置的观察者模式

Java内置的主题

Java内部的主题存在java.util包下,其源码如下:

  1. public class Observable {
  2.     private boolean changed = false;
  3.     private Vector<Observer> obs;
  5.     public Observable() {
  6.         obs = new Vector<>();
  7.     }
  9.     public synchronized void addObserver(Observer o) {
  10.         if (o == null)
  11.             throw new NullPointerException();
  12.         if (!obs.contains(o)) {
  13.             obs.addElement(o);
  14.         }
  15.     }
  17.     public synchronized void deleteObserver(Observer o) {
  18.         obs.removeElement(o);
  19.     }
  21.     public void notifyObservers() {
  22.         notifyObservers(null);
  23.     }
  25.     public void notifyObservers(Object arg) {
  27.         Object[] arrLocal;
  29.         synchronized (this) {
  30.             if (!changed)
  31.                 return;
  32.             arrLocal = obs.toArray();
  33.             clearChanged();
  34.         }
  36.         for (int i = arrLocal.length-1; i>=0; i--)
  37.             ((Observer)arrLocal[i]).update(this, arg);
  38.     }
  40.     public synchronized void deleteObservers() {
  41.         obs.removeAllElements();
  42.     }
  44.     protected synchronized void setChanged() {
  45.         changed = true;
  46.     }
  48.     protected synchronized void clearChanged() {
  49.         changed = false;
  50.     }
  52.     public synchronized boolean hasChanged() {
  53.         return changed;
  54.     }
  56.     public synchronized int countObservers() {
  57.         return obs.size();
  58.     }
  59. }

内置的主题类提供:增加观察者,删除观察者,删除所有观察者,提醒某个观察者,提醒所有观察者,获取观察者的数量,设置数据变化等方法.

与自定义的主题不同的是:

  1. java内置的主题是一个类不是一个接口.
  2. java内置的主题必须手动设置数据变化,即setChanged().否则主题不会通知观察者.

Java内置的观察者

java内置的主题在java.util包下,其源码如下:

  1. public interface Observer {
  2.     void update(Observable o, Object arg);
  3. }

与自定义的观察者一致.

使用Java内置的观察者模式实现气象站

WeatherData类

  1. public class WeatherData extends Observable{
  3.     private float temp;
  4.     private float humidity;
  5.     private float pressure;
  7.     public WeatherData(){}
  9.     public void setWeatherData(float temp, float humidity, float pressure){
  10.         this.temp = temp;
  11.         this.humidity = humidity;
  12.         this.pressure = pressure;
  13.         dataChanged();
  14.     }
  16.     public void dataChanged(){
  17.         setChanged();
  18.         notifyObservers();
  19.     }
  21.     public float getTemp() {
  22.         return temp;
  23.     }
  25.     public float getHumidity() {
  26.         return humidity;
  27.     }
  29.     public float getPressure() {
  30.         return pressure;
  31.     }
  32. }

CurrentConditionsDisplay

  1. public class CurrentConditionsDisplay implements Observer, DisplayElement {
  3.     private Observable observable;
  4.     public CurrentConditionsDisplay(Observable observable){
  5.         this.observable = observable;
  6.         observable.addObserver(this);
  7.     }
  9.     public void unregister(){
  10.         observable.deleteObserver(this);
  11.     }
  13.     public void display() {
  14.         String displayData = "CurrentConditions[temp=" + temp + ", humidity=" + humidity + ", pressure="
  15.                 + pressure + "]";
  16.         System.out.println(displayData);
  17.     }
  19.     private float temp;
  20.     private float humidity;
  21.     private float pressure;
  23.     @Override
  24.     public void update(Observable o, Object arg) {
  25.         if (o instanceof WeatherData) {
  26.             WeatherData weatherData = (WeatherData) o;
  27.             this.temp = weatherData.getTemp();
  28.             this.humidity = weatherData.getHumidity();
  29.             this.pressure = weatherData.getPressure();
  30.             display();
  31.         }
  32.     }
  33. }

AvgStateDisplay

  1. public class AvgStateDisplay implements Observer, DisplayElement{
  3.     private Observable observable;
  4.     public AvgStateDisplay(Observable observable){
  5.         observable.addObserver(this);
  6.         this.observable = observable;
  7.     }
  9.     public void unregister(){
  10.         observable.deleteObserver(this);
  11.     }
  13.     public void display() {
  14.         System.out.println(getShowInfo());
  15.     }
  17.     private String getShowInfo(){
  18.         StringBuilder displayData = new StringBuilder();
  19.         if (tempList.size() == 0) {
  20.             displayData.append("暂时没有数据...");
  21.             return displayData.toString();
  22.         }
  24.         float tempAve = calculatorAve(tempList);
  25.         displayData.append("平均气温:" + tempAve);
  27.         float humidityAve = calculatorAve(humidityList);
  28.         displayData.append(",平均湿度:" + humidityAve);
  30.         float pressureAve = calculatorAve(pressureList);
  31.         displayData.append(",平均压强:" + pressureAve);
  33.         return displayData.toString();
  34.     }
  36.     private float calculatorAve(List<Float> dataList){
  37.         float sum = 0F;
  38.         for (Float float1 : dataList) {
  39.             sum = sum + float1;
  40.         }
  41.         float ave = sum/dataList.size();
  42.         return ave;
  43.     }
  45.     private List<Float> tempList;
  46.     private float temp;
  47.     private List<Float> humidityList;
  48.     private float humidity;
  49.     private List<Float> pressureList;
  50.     private float pressure;
  52.     @Override
  53.     public void update(Observable o, Object arg) {
  54.         if (o instanceof WeatherData) {
  55.             WeatherData weatherData = (WeatherData) o;
  56.             this.temp = weatherData.getTemp();
  57.             this.humidity = weatherData.getHumidity();
  58.             this.pressure = weatherData.getPressure();
  60.             if (tempList == null) {
  61.                 tempList = new ArrayList<Float>();
  62.             }
  63.             tempList.add(temp);
  65.             if (humidityList == null) {
  66.                 humidityList = new ArrayList<Float>();
  67.             }
  68.             humidityList.add(humidity);
  70.             if (pressureList == null) {
  71.                 pressureList = new ArrayList<Float>();
  72.             }
  73.             pressureList.add(pressure);
  75.             display();
  76.         }
  77.     }
  78. }

HeatIndexDisplay

  1. public class HeatIndexDisplay implements Observer, DisplayElement{
  3.     private Observable observable;
  4.     public HeatIndexDisplay(Observable observable){
  5.         observable.addObserver(this);
  6.         this.observable = observable;
  7.     }
  9.     public void unregister(){
  10.         observable.deleteObserver(this);
  11.     }
  13.     @Override
  14.     public void display() {
  15.         System.out.println("当前酷热指数:" + getHeatIndex());
  16.     }
  18.     private float getHeatIndex(){
  19.         float heatIndex = 0F;
  20.         heatIndex = (float) (temp*Math.PI + humidity*Math.E + pressure*1.01315)/5;
  21.         return heatIndex;
  22.     }
  24.     private float temp;
  25.     private float humidity;
  26.     private float pressure;
  28.     @Override
  29.     public void update(Observable o, Object arg) {
  30.         if (o instanceof WeatherData) {
  31.             WeatherData weatherData = (WeatherData) o;
  32.             this.temp = weatherData.getTemp();
  33.             this.humidity = weatherData.getHumidity();
  34.             this.pressure = weatherData.getPressure();
  35.             display();
  36.         }
  37.     }
  38. }

测试类

  1. public class WeatherStation {
  3.     public static void main(String[] args) {
  4.         WeatherData weatherData = new WeatherData();
  6.         CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
  7.         AvgStateDisplay stateDisplay = new AvgStateDisplay(weatherData);
  8.         HeatIndexDisplay heatIndexDisplay = new HeatIndexDisplay(weatherData);
  10.         weatherData.setWeatherData(25.0F, 80F, 1.01F);
  11.         try {
  12.             Thread.sleep(3000);
  13.         } catch (InterruptedException e) {
  14.             e.printStackTrace();
  15.         }
  16.         weatherData.setWeatherData(26.2F, 76F, 1.02F);
  17.         try {
  18.             Thread.sleep(3000);
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  22.         weatherData.setWeatherData(27.8F, 70F, 1.01F);
  23.     }
  24. }

测试结果如下:

  1. 当前酷热指数:59.40513
  2. 平均气温:25.0,平均湿度:80.0,平均压强:1.01
  3. CurrentConditions[temp=25.0, humidity=80.0, pressure=1.01]
  4. 当前酷热指数:57.98651
  5. 平均气温:25.6,平均湿度:78.0,平均压强:1.015
  6. CurrentConditions[temp=26.2, humidity=76.0, pressure=1.02]
  7. 当前酷热指数:55.727856
  8. 平均气温:26.333334,平均湿度:75.333336,平均压强:1.0133333
  9. CurrentConditions[temp=27.8, humidity=70.0, pressure=1.01]

从上面的结果可以看出与自定义的观察者模式显示的一致.

总结

观察者模式的使用过程如下:

  1. 数据变化的对象继承Observable类.在数据变化后调用setChanged()方法.
  2. 观察者类实现Observer接口,并重新update()方法.
  3. 使用时用观察者内部持有的可观察接口注册与解除注册为观察者.
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注