Java常用类库——观察者设计模式

观察者设计模式

现在很多的购房者都在关注着房子的价格变化，每当房子价格变化的时候，所有的购房者都可以观察得到。实际上以上的购房者都属于观察者，他们都关注着房子的价格。

如果要想实现观察者模式，则必须依靠java.util包中提供的Observable类和Observer接口。

查看API如下：

查看java.util包中的Observable类如下：

    java.util   
    类 Observable  
      
    java.lang.Object  
      继承者 java.util.Observable  
    public class Observable  
    extends Object  
    此类表示模型视图范例中的 observable 对象，或者说“数据”。可将其子类化，表示应用程序想要观察的对象。  
      
    一个 observable 对象可以有一个或多个观察者。观察者可以是实现了 Observer 接口的任意对象。一个 observable 实例改变后
，调用 Observable 的 notifyObservers 
方法的应用程序会通过调用观察者的 update 方法来通知观察者该实例发生了改变。  
      
    未指定发送通知的顺序。Observable 类中所提供的默认实现将按照其注册的重要性顺序来通知 Observers，但是子类可能改变此顺序，
从而使用非固定顺序在单独的线程上发送通知，或者也可能保证其子类遵从其所选择的顺序。  
      
    注意，此通知机制与线程无关，并且与 Object 类的 wait 和 notify 机制完全独立。  
      
    新创建一个 observable 对象时，其观察者集是空的。当且仅当 equals 方法为两个观察者返回 true 时，才认为它们是相同的。  
      
    从以下版本开始：  
    JDK1.0  
    另请参见：  
    notifyObservers(), notifyObservers(java.lang.Object), Observer, Observer.update(java.util.Observable, java.lang.Object)  
      
    构造方法摘要  
    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。  
       
    从类 java.lang.Object 继承的方法  
    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait  
       
      
    构造方法详细信息  
    Observable  
      
    public Observable()  
    构造一个带有零个观察者的 Observable。  
    方法详细信息  
    addObserver  
      
    public void addObserver(Observer o)  
    如果观察者与集合中已有的观察者不同，则向对象的观察者集中添加此观察者。未指定向多个观察者发送通知的顺序。请参阅该类的注释。  
    参数：  
    o - 要添加的观察者。  
    抛出：  
    NullPointerException - 如果参数 o 为 null。  
    deleteObserver  
      
    public void deleteObserver(Observer o)  
    从对象的观察者集合中删除某个观察者。向此方法传递 null 将使其无效。  
    参数：  
    o - 要删除的观察者。  
    notifyObservers  
      
    public void notifyObservers()  
    如果 hasChanged 方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来指示此对象不再改变。  
    每个观察者都有其 update 方法，其调用参数有两个：observable 对象和 null。换句话说，此方法等效于：  
      
    notifyObservers(null)  
    另请参见：  
    clearChanged(), hasChanged(), Observer.update(java.util.Observable, java.lang.Object)  
    notifyObservers  
      
    public void notifyObservers(Object arg)  
    如果 hasChanged 方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来指示此对象不再改变。  
    每个观察者都有其 update 方法，其调用参数有两个：observable 对象和 arg 参数。  
      
    参数：  
    arg - 任意对象。  
    另请参见：  
    clearChanged(), hasChanged(), Observer.update(java.util.Observable, java.lang.Object)  
    deleteObservers  
      
    public void deleteObservers()  
    清除观察者列表，使此对象不再有任何观察者。  
    setChanged  
      
    protected void setChanged()  
    标记此 Observable 对象为已改变的对象；现在 hasChanged 方法将返回 true。  
    clearChanged  
      
    protected void clearChanged()  
    指示对象不再改变，或者它已对其所有的观察者通知了最近的改变，所以 hasChanged 方法将返回 false。notifyObservers 方法自动调用此方法。  
    另请参见：  
    notifyObservers(), notifyObservers(java.lang.Object)  
    hasChanged  
      
    public boolean hasChanged()  
    测试对象是否改变。  
    返回：  
    当且仅当在此对象上最近调用了 setChanged 方法，而不是 clearChanged 方法时，才返回 true；否则返回 false。  
    另请参见：  
    clearChanged(), setChanged()  
    countObservers  
      
    public int countObservers()  
    返回 Observable 对象的观察者数目。  
    返回：  
    对象的观察者数目。  

程序代码示例如下：

    import java.util.* ;  
    class House extends Observable{ // 表示房子可以被观察  
        private float price ;// 价钱  
        public House(float price){  
            this.price = price ;  
        }  
        public float getPrice(){  
            return this.price ;  
        }  
        public void setPrice(float price){  
            // 每一次修改的时候都应该引起观察者的注意  
            super.setChanged() ;    // 设置变化点  
            super.notifyObservers(price) ;// 价格被改变  
            this.price = price ;  
        }  
        public String toString(){  
            return "房子价格为：" + this.price ;  
        }  
    };   
    class HousePriceObserver implements Observer{  
        private String name ;  
        public HousePriceObserver(String name){ // 设置每一个购房者的名字  
            this.name = name ;  
        }  
        public void update(Observable o,Object arg){  
            if(arg instanceof Float){  
                System.out.print(this.name + "观察到价格更改为：") ;  
                System.out.println(((Float)arg).floatValue()) ;  
            }  
        }  
    };  
    public class ObserDemo01{  
        public static void main(String args[]){  
            House h = new House(1000000) ;  
            HousePriceObserver hpo1 = new HousePriceObserver("购房者A") ;  
            HousePriceObserver hpo2 = new HousePriceObserver("购房者B") ;  
            HousePriceObserver hpo3 = new HousePriceObserver("购房者C") ;  
            h.addObserver(hpo1) ;  
            h.addObserver(hpo2) ;  
            h.addObserver(hpo3) ;  
            System.out.println(h) ; // 输出房子价格  
            h.setPrice(666666) ;    // 修改房子价格  
            System.out.println(h) ; // 输出房子价格  
        }  
    };  

总结：

在Observer接口中的update方法里面的两个参数：

o：具体表示发出通知的Observable类的对象。即表示哪个被观察者发出了通知。

arg：需要被观察的内容。

 

被观察者即可被观察的对象 就是继承于Observable的类。其中发送通知时一定调用super.setChanged()方法和notifyObservers(XXX)方法。

 

此设计模式是Java本身的机制，不使用Observer接口和Observable类也是可以实现的，但是比较复杂。