mAdapter.notifyDataSetChanged();

咱们先看看观察者模式和接口回调的关系：

https://blog.csdn.net/cauchyweierstrass/article/details/44593807#

接口回调：

public interface CallBack {
    public void oncall();
}

public class CallBackImp implements CallBack{
    @Override
    public void oncall() {
        System.out.println("回调函数被调用");
    }
}

public class A {
    private CallBack callback;
    //注册一个事件
    public void register(CallBack callback){
        this.callback = callback;
    }
    // 需要调用的时候回调
    public void call(){
        callback.oncall();
    }
}

public static void main(String[] args) {
    CallBack callback = new CallBackImp();
    A a = new A();
    a.register(callback);
    a.call();
}

观察者模式：

public interface Observer {
    public void update();
}

public class ConcreteObserver1 implements  Observer{
 
    public void update() {
        System.out.println("ConcreteObserver1获得更新");
    }
}

public class ConcreteObserver2 implements  Observer{
 
    public void update() {
        System.out.println("ConcreteObserver2获得更新");
    }
}

public class Subject {
 
    List<Observer> lists = new ArrayList<Observer>();
    
    //注册一个事件
    public void register(Observer observer){
        lists.add(observer);
    }
 
    public void _notify(){
        for (Observer observer : lists) {
            observer.update();
        }
    }
    
    public void unRegister(Observer observer){
        lists.remove(observer);
    }
}

public static void main(String[] args) {
    Observer observer1 = new ConcreteObserver1();
    Observer observer2 = new ConcreteObserver2();
    Subject subject = new Subject();
    subject.register(observer1);
    subject.register(observer2);
    subject._notify();
    //取消观察者1的注册
    subject.unRegister(observer1);
    subject._notify();
}

实际上，回调是观察者模式的简单形式。区别是观察者模式里面目标类维护了所有观察者的引用，而回调里面只是维护了一个引用。观察者模式也就是将回调上升到设计模式的理论高度上了而已。

此处使用RecyclerView来研究下：

mAdapter.notifyDataSetChanged();

之后就来到了
RecyclerView.Adaapter.java

  public final void notifyDataSetChanged() {
            mObservable.notifyChanged();
        }
继续向下：
RecyclerView.AdapterDataObservable.java

static class AdapterDataObservable extends Observable<AdapterDataObserver> {
     public void notifyChanged() {
            for (int i = mObservers.size() - 1; i >= 0; i--) {
                mObservers.get(i).onChanged();
            }
        }
}
继续向下：
RecyclerView.AdapterDataObserver.java

public abstract static class AdapterDataObserver {
        public void onChanged() {
            // Do nothing
        }
}

继续向下：
RecyclerView.RecyclerViewDataObserver.java

private class RecyclerViewDataObserver extends AdapterDataObserver {
        RecyclerViewDataObserver() {
        }

        @Override
        public void onChanged() {
            assertNotInLayoutOrScroll(null);
            mState.mStructureChanged = true;
            processDataSetCompletelyChanged(true);
            if (!mAdapterHelper.hasPendingUpdates()) {
                requestLayout();
            }
        }

重点就两个东西：
1：mObservable
2：mObservers

先看第一个：mObservable

    public abstract static class Adapter<VH extends ViewHolder> {
        private final AdapterDataObservable mObservable = new AdapterDataObservable();

第二个：mObserver

RecyclerView.java
private final RecyclerViewDataObserver mObserver = new RecyclerViewDataObserver();

那他们是在哪里关联的呢？

看一下

mRecyclerView.setAdapter(mPresenter.getAdapter());

RecyclerView.java
    public void setAdapter(Adapter adapter) {
        // bail out if layout is frozen
        setLayoutFrozen(false);
        setAdapterInternal(adapter, false, true);
        processDataSetCompletelyChanged(false);
        requestLayout();
    }

private void setAdapterInternal(Adapter adapter, boolean compatibleWithPrevious,
            boolean removeAndRecycleViews) {
        if (mAdapter != null) {
            mAdapter.unregisterAdapterDataObserver(mObserver);
            mAdapter.onDetachedFromRecyclerView(this);
        }
        if (!compatibleWithPrevious || removeAndRecycleViews) {
            removeAndRecycleViews();
        }
        mAdapterHelper.reset();
        final Adapter oldAdapter = mAdapter;
        mAdapter = adapter;
        if (adapter != null) {
            adapter.registerAdapterDataObserver(mObserver);
            adapter.onAttachedToRecyclerView(this);
        }
        if (mLayout != null) {
            mLayout.onAdapterChanged(oldAdapter, mAdapter);
        }
        mRecycler.onAdapterChanged(oldAdapter, mAdapter, compatibleWithPrevious);
        mState.mStructureChanged = true;
    }

  public abstract static class Adapter<VH extends ViewHolder> {
   public void registerAdapterDataObserver(@NonNull AdapterDataObserver observer) {
            mObservable.registerObserver(observer);
        }
}

我们来按照上面的模板梳理下：

public static void main(String[] args) {
    CallBack callback = new CallBackImp();
    A a = new A();
    a.register(callback);
    a.call();
}

private final RecyclerViewDataObserver mObserver = new RecyclerViewDataObserver();
private final AdapterDataObservable mObservable = new AdapterDataObservable();
               mObservable.registerObserver(observer);
               mObservable.notifyChanged();

题外话一下，官方把相关的类全放在一个.java文件里，我们是不是也可以这样呢。比如adapter放在fragment里面，建造数据model时，不用一个层级一个.java文件，而是全放在一起。