观察者模式Observer

初学java的观察者模式，今天总结了下，希望指正。

　　观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。

　　这个主题对象在状态上发生变化时，会通知所有观察者对象，让它们能够自动更新自己。

 

所谓观察者模式，举个例子现在许多购房者都密切观察者房价的变化，当房价变化时，所有购房者都能观察到，以上的购房者属于观察者，这便是观察者模式。

       Java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。

java.util.Observable中有两个方法对Observer特别重要

1、setChanged()方法

/** 
02. * Sets the changed flag for this {@code Observable}. After calling 
03. * {@code setChanged()}, {@code hasChanged()} will return {@code true}. 
04. */  
05.protected void setChanged() {  
06.    changed = true;  
07.}  

2、notifyObservers()方法 / notifyObservers(Object data)方法

/** 
02. * If {@code hasChanged()} returns {@code true}, calls the {@code update()} 
03. * method for every observer in the list of observers using null as the 
04. * argument. Afterwards, calls {@code clearChanged()}. 
05. * <p> 
06. * Equivalent to calling {@code notifyObservers(null)}. 
07. */  
08.public void notifyObservers() {  
09.    notifyObservers(null);  
10.}  
11.  
12./** 
13. * If {@code hasChanged()} returns {@code true}, calls the {@code update()} 
14. * method for every Observer in the list of observers using the specified 
15. * argument. Afterwards calls {@code clearChanged()}. 
16. * 
17. * @param data 
18. *            the argument passed to {@code update()}. 
19. */  
20.@SuppressWarnings("unchecked")  
21.public void notifyObservers(Object data) {  
22.    int size = 0;  
23.    Observer[] arrays = null;  
24.    synchronized (this) {  
25.        if (hasChanged()) {  
26.            clearChanged();  
27.            size = observers.size();  
28.            arrays = new Observer[size];  
29.            observers.toArray(arrays);  
30.        }  
31.    }  
32.    if (arrays != null) {  
33.        for (Observer observer : arrays) {  
34.            observer.update(this, data);  
35.        }  
36.    }  
37.}  

以上两个方法十分重要

setChanged()方法 ——

用来设置一个内部标志位注明数据发生了变化

notifyObservers()方法 / notifyObservers(Object data)方法 ——

通知所有的Observer数据发生了变化，这时所有的Observer会自动调用复写好的update(Observable observable, Object data)方法来做一些处理（比如说画面数据的更新）。

我们可以看到通知Observer有两个方法，一个无参，一个有参。那么这个参数有什么作用呢？

其中一个作用：现在我不想通知所有的Observer，而只想其中一个指定的Observer做一些处理，那么就可以传一个参数作为ID，然后在所有的Observer中判断，每个Observer判断只有接收到底参数ID是属于自己的才做一些处理。

当然参数还有其他作用，我只是举了个例子。

注意： 只有在setChanged()被调用后，notifyObservers()才会去调用update()，否则什么都不干。

       示例代码如下：

import java.util.Observable;  
import java.util.Observer;  
  
class House extends Observable {  
    private float price;  
  
    public void setPrice(float price) {  
        this.setChanged();// 设置变化点  
        this.notifyObservers(price);// 通知所有观察者价格改变  
        this.price = price;  
    }  
  
    public float getPrice() {  
        return this.price;  
    }  
  
    public House(float price) {  
        this.price = price;  
    }  
  
    public String toString() {  
        return "房子价格为: " + this.price;  
    }  
}  
  
class HousePriceObserver implements Observer {  
    private String name;  
  
    public HousePriceObserver(String name) {  
        super();  
        this.name = name;  
    }  
  
    @Override  
    public void update(Observable o, Object arg) {// 只要改变了 observable 对象就调用此方法  
        if (arg instanceof Float) {  
            System.out.println(this.name + "观察的价格更改为:"  
                    + ((Float) arg).floatValue());  
        }  
  
    }  
  
}  
  
public class ObserTest {  
    public static void main(String[] args) {  
        House house = new House(1000000);  
        HousePriceObserver hpo1 = new HousePriceObserver("购房者A");  
        HousePriceObserver hpo2 = new HousePriceObserver("购房者B");  
        HousePriceObserver hpo3 = new HousePriceObserver("购房者C");  
        house.addObserver(hpo1);// 给房子注册观察者  
        house.addObserver(hpo2);// 给房子注册观察者  
        house.addObserver(hpo3);// 给房子注册观察者  

        System.out.println(house.toString());//输出房子价格  
        // 修改房子价格，会触发update(Observable o, Object arg)方法通知购房者新的房价信息  
        house.setPrice(2222222);//   
        System.out.println(house.toString());//再次输出房子价格  
    }  
}