观察者模式--回调模式

不要字面的理解监听器，它不是主动去检查事件是否发生的，所以不存在每时每刻这种说法。早期是有隔一定时间间隔之后去检查轮询。
对于我们来说，Android中的Listener其实只是一种Callback，是回调方法。是当事件发生时，由事件发起者或者内部处理者调用的方法。（该方法为一个接口里的方法），在要做出反应的这一方先implements这个接口，set（相当于订阅，将观察者（监听器）与被观察者（被监听的）联系起来了），将接口方法实现。于是监听器就实现了。

• 基本原理

public class Employee{
  private Callback mCallback;//定义回调接口对象成员变量
  public interface Callback{//声明回调接口，相当于观察者
    public abstract void work();
  };
  public void setCallback (Callback callback){//设置回调接口对象的成员变量
    this.mCallback = callback;
  }
  public void dowork(){//调用回调接口中的方法
    mCallback.work();
  }
}

public class Boss{
    private Employee employee;
    public void setCallback(new Employee.Callback(){//形成订阅关系
        @Override 
        public void work(){
            System.out.println("click");
        }
    })
      public void onCall(){
         employee.dowork();
      }
  
}

• listener的话 就把 callback==》listener相当于观察者，work==》onXXX，Employee==》View啊 item等等被观察者.。当employee执行了onwork方法，就会调用System.out.println("click");

• listview中adapter的notifydatachange也是观察者模式。部分源码如下：

public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {
    
  private final DataSetObservable mDataSetObservable = new DataSetObservable();// 相当于Employee，被观察者

     //相当于setcallback，DataSetObserver观察者
    public void registerDataSetObserver(DataSetObserver observer) {
        mDataSetObservable.registerObserver(observer);
    }
    /**
     * Notifies the attached observers that the underlying data has been changed
     * and any View reflecting the data set should refresh itself.
    */
    //相当于 onCall;     
    public void notifyDataSetChanged() {
        mDataSetObservable.notifyChanged();
    }
}

public class DataSetObservable extends Observable<DataSetObserver> {
    /**
     * Invokes {@link DataSetObserver#onChanged} on each observer.
     * Called when the contents of the data set have changed.  The recipient
     * will obtain the new contents the next time it queries the data set.
     */
    public void notifyChanged() {
        synchronized(mObservers) {
            // since onChanged() is implemented by the app, it could do anything, including
            // removing itself from {@link mObservers} - and that could cause problems if
            // an iterator is used on the ArrayList {@link mObservers}.
            // to avoid such problems, just march thru the list in the reverse order.
            //相当于所有的mCallback.work();
            for (int i = mObservers.size() - 1; i >= 0; i--) {
                mObservers.get(i).onChanged();
            }
        }
    }

    /**
     * Invokes {@link DataSetObserver#onInvalidated} on each observer.
     * Called when the data set is no longer valid and cannot be queried again,
     * such as when the data set has been closed.
     */
    public void notifyInvalidated() {
        synchronized (mObservers) {
            for (int i = mObservers.size() - 1; i >= 0; i--) {
                mObservers.get(i).onInvalidated();
            }
        }
    }
}