设计模式之观察者

观察者模式 Observer定义

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

        说明：

        （1）对象的一对多的关系中，"一"表示被观察者或称为主题（Subject），"多"表示观察者（Observer）；

        （2）主题是具有状态的对象，并可以控制这些状态；而观察者是使用这些状态的对象；

        （3）观察者模式中，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，让它们能够自动更新自己。

        （4）观察者模式的经典例子：出版者（主题对象） + 订阅者（观察者对象），即一个出版社可有多个订阅者，每个订阅者通过注册向出版社订阅报纸，每当出版社出版一批报纸时就会通知所有订阅者，这样订阅者们就可以及时拿到报纸做自己想做的事了，当然订阅者也可以取消注册，则出版社不会再通知该订阅者。

观察者模式 Observer一般的组成

        观察者模式的基本组成部分有：一个Subject接口，一个Subject接口的实现类，一个观察者Observer接口，以及若干个观察者Observer接口的实现类，分别说一下各自功能：

        （1）抽象主题角色：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。

        （2）抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。

        （3）具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。

        （4）具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。通常用一个子类实现。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。

观察者模式 Observer实例

        以天气更新为例，气象站获取到新数据时便更新最新天气参数，数据包括温度、天气、风的级数；并要求显示当天、明天的以上参数，仅显示后天的天气和温度。

        （1）Subject接口

1 2 3 4 5 6 7 8 9

public  interface  ISubject {                                public  void  registerObserver(IObserver observer);                            public  void  removeObserver(IObserver observer);                            public  void  notifyObserver();                        }

       （2）Subject接口实现类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

public  class  WeatherSubject  implements  ISubject{                      //保存所有对观察者对象的引用的集合              private  ArrayList<IObserver> observersList;              private  double  tempretrue;              private  String weather;              private  int  windClass;                            public  WeatherSubject(){                  observersList =  new  ArrayList<IObserver>();              }                        /**               * 注册观察者的实现               */              public  void  registerObserver(IObserver observer) {                  observersList.add(observer);              }                        /**               * 移除观察者的实现               */              public  void  removeObserver(IObserver observer) {                  int  index = observersList.indexOf(observer);                  if (index >=  0 ){                      observersList.remove(index);                  }                                }                        /**               * 更新观察者的实现               */              public  void  notifyObserver() {                  for ( int  i= 0 ;i<observersList.size();i++){                      IObserver observer = observersList.get(i);                      observer.update(tempretrue, weather, windClass);                  }              }                            /**               * 设置新数据               * @param tempretrue               * @param weather               * @param windClass               */              public  void  setData( int  tempretrue, String weather,  int  windClass){                  this .tempretrue = tempretrue;                  this .weather = weather;                  this .windClass = windClass;              }                                  }

        （3）Observer接口

1 2 3

public  interface  IObserver {                      public  void  update( double  temp, String wea,  int  wind);          }

          （4）Observer接口的实现类多个--分别为今天，明天，后天天气

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public  class  TodayObserver  implements  IObserver{                      private  ISubject subject;                            public  TodayObserver(ISubject subject){                  //如果需要，具体观察者角色可以保存一个指向具体主题角色的引用                  this .subject = subject;                  subject.registerObserver( this );              }                            public  void  update( double  temp, String wea,  int  wind) {                  System.out.println( "Today tempreture:" +temp);                  System.out.println( "Today weather:" +wea);                  System.out.println( "Today wind class:" +wind);              }          }

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public  class  TomorrowObserver  implements  IObserver{                      private  ISubject subject;                            public  TomorrowObserver(ISubject subject){                  this .subject = subject;                  subject.registerObserver( this );              }                            public  void  update( double  temp, String wea,  int  wind) {                  System.out.println( "Tomorrow tempreture:" +temp);                  System.out.println( "Tomorrow weather:" +wea);                  System.out.println( "Tomorrow wind class:" +wind);              }          }

1 2 3 4 5 6 7 8 9 10 11 12 13

public  class  TomorrowAfterObserver  implements  IObserver{                      private  ISubject subject;                            public  TomorrowAfterObserver(ISubject subject){                  this .subject = subject;                  subject.registerObserver( this );              }                            public  void  update( double  temp, String wea,  int  wind) {                  System.out.println( "The day after tomorrow tempreture:" +temp);                  System.out.println( "The day after tomorrow weather:" +wea);              }          }

        （5）测试类

1 2 3 4 5 6 7 8 9 10 11 12

public  class  MainTest {                      public  static  void  main(String[] args) {                                    WeatherSubject subject =  new  WeatherSubject();                  //观察者的分别注册                  TodayObserver today =  new  TodayObserver(subject);                  TomorrowObserver tomorrow =  new  TomorrowObserver(subject);                  TomorrowAfterObserver tomorrowAfter =  new  TomorrowAfterObserver(subject);                  //被观察者的全部通知更新                  subject.notifyObserver();              }          }

观察者模式 Observer的其他说明

    1.观察者模式体现了松耦合的设计原则

    （1）如果两个对象之间松耦合，那么他们依然可以交互，但是不太清楚彼此的细节，例如
    Subject只需知道Observer实现了哪个接口；
    （2）观察者模式提供了java培训机构排名的一种对象设计，让主题和观察者之间松耦合；
    （3）保证任何时候都可以增加新的观察者，同理亦可以在任何时候删除一个观察者，对主题没有影响；

    2.在JDK中还有很多地方可以找到观察者模式---例如Button的监听，Button则是具有状态（按下、抬起），而给Button注册的监听可以多个，并且可以使用这些状态，一旦Button状态改变，监听们会立即根据该状态来做出不同的响应。

    3.体现了--找出程序中变化的方面，并将其与固定不变的方面相分离--的设计原则：

        在观察者模式中，会变化的是主题的状态，以及观察者的数目和类型。在这个模式中，你可以改变依赖于主题状态的对象，却不用改变主题；

    4.体现了--针对接口编程，不针对实现编程--的设计原则：

        主题与观察者都适用接口，观察者利用主题的接口向主题注册，而主题利用观察者接口向观察者发出通知，同时具有松耦合的特点；

    5.体现了--多用组合，少用继承--的设计原则：

        观察者模式利用"组合"将许多观察者组合进主题中。对象这件的这种关系不是由继承关系产生的，而是在运行时利用组合的关系产生的。