常用设计模式----观察者模式

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

设计原则：
为了交互对象之间的松耦合设计而努力。


java中内置的观察者模式：
java.util.Observer（接口）和java.util.Observable（类，这也正是其局限性，不能有效的扩展（比如已经extends其他类的情况下））
--------------------------
以下是对util中的Observable的改进:

//抽象出一层
public interface IObservable {
    //注册观察者
    void addObserver(Observer o);
    //取消注册
    void deleteObserver(Observer o);
    //通知观察者们（拉的形式）
    void notifyObservers();
    //推的形式
    void notifyObservers(Object arg);
}

//可观察者对象的实现
class Observable implements IObservable{
 private boolean changed = false;
 private List<Observer> obs;

 public Observable() {
  obs = new ArrayList<Observer>();
 }
 public synchronized void addObserver(Observer o) {
  if (o == null)
   throw new NullPointerException();
  if (!obs.contains(o)) {
   obs.add(o);
  }
 }

 public synchronized void deleteObserver(Observer o) {
  obs.remove(o);
 }

 public void notifyObservers() {
  notifyObservers(null);
 }
 public void notifyObservers(Object arg) {
  Object[] arrLocal;

  synchronized (this) {
   if (!changed)
    return;
   arrLocal = obs.toArray();
   clearChanged();
  }

  for (int i = arrLocal.length - 1; i >= 0; i--)
   ((Observer) arrLocal[i]).update(this, arg);
 }

 public synchronized void deleteObservers() {obs.clear();}
 protected synchronized void setChanged()   {changed = true;}
 protected synchronized void clearChanged() {changed = false;}
 public synchronized boolean hasChanged()   {return changed;}
 public synchronized int countObservers()   {return obs.size();}
}

//观察者需要实现统一的接口
interface IObserver {
    void update(IObservable o, Object arg);
}

//观察者实现类
class Observer implements IObserver {
 private IObservable obs;

 public Observer(IObservable obs) {
  this.obs = obs;
  obs.addObserver(this);
 }

 @Override
 public void update(IObservable o, Object arg) {
  //观察者自己的更新方法
        //...
 }
}

//新建一个主题对象，传递到新建的观察者对象中。调用主题对象的notify 就会触发观察者对象了。

-观察者模式定义了对象之间的一对多的关系。
-主题（也就是可观察者）用一个共同的接口来更新观察者。
-观察者和可观察者（主题）之间用松耦合方式结合（loosecoupling），可观察者不知道观察者的细节，只知道观察者实现了观察者接口。
-使用该模式时，可以从被观察者处推（push）或拉（pull）数据（不过，推的方式比较推崇）。
-有多个观察者时不可以依赖特定的通知次序。
-Java有多种观察者模式的实现，包括通用的java.util.Observalbe。
-许多UI框架比如SWT等的添加监听器的行为 都是观察者模式的实现。