观察者模式常用于一对多的监听情景，并且被监听者可以实现监听者的回调，也就是说被监听者能够触发监听者的动作，该动作就是回调。

观察者模式的特点：

1.被观察者不知道具体的观察者是谁，只知道自己被观察了，并且在合适的时机进行广播，让感兴趣的观察者知道发生了什么事情。

2.观察者依赖于被观察者，被观察者不依赖于观察者，是单向关系，耦合程度不高。没有被观察者，观察者无法工作；没有观察者，被观察者该干啥干啥，因为被观察者本来就不清楚谁观察他，发广播是被观察的个人行为。

3.通常被观察者出现行为上的变化，需要观察者做出反馈。显然一般情况下观察者并不知道被观察者啥时候会有变化，因此该反馈是一种被动反馈，实现的是一种回调机制。

观察者

package com.example.listenertest;
 
public abstract class Observer {
    //添加被观察者的引用
    protected Subject subject;
    //更新的抽象方法
    public abstract void update();
}

通常观察者需要一个共有的父类，通常为抽象类。

可见，观察者是依赖于被观察者的，观察者必须有一个具体的被观察者的引用，自身才能实例化。

此外，update函数就是观察者做出的反馈，是被被观察者调用的，因此是一种回调函数。

被观察者

package com.example.listenertest;
 
import java.util.ArrayList;
import java.util.List;
 
public class Subject {
    //观察者列表
    private List observerList = new ArrayList();
    //自身的一个状态变量
    private int state;
 
    //得到自身状态变量
    public int getState(){
        return state;
    }
 
    //设置自身状态变量
    public void setState(int state){
        this.state = state;
        //状态变量改变了，需要通知所有观察者
        notifyAllObservers();
    }
 
    //观察者通知方法
    public void notifyAllObservers(){
        //便利观察者列表
        for(Observer observer:observerList){
            //调用观察者的更新函数
            observer.update();
        }
    }
 
    //增加观察者
    public void attach(Observer observer){
        observerList.add(observer);
    }
}

可以看出，被观察者并不知道观察者具体是谁，也不依赖于观察者存在。

被观察者只知道一个观察者队列，并且拥有将观察者加入到观察者队列的方法。

当观察者在某个时机执行某个动作后，会对观察者队列里的所有的观察者进行通知，而通知的操作就是实现回调，调用观察者的回调函数，实现观察者的反馈机制。

具体执行

package com.example.listenertest;
 
import android.util.Log;
 
public class RedObserver extends Observer{
 
    //观察者是依赖于被观察者的，因此必须明确自己观察的是谁
    public RedObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }
    //实际上实现了一种回调机制，update就是回调函数
    @Override
    public void update() {
        Log.d("huankuai!","red subject state: "+this.subject.getState());
    }
}

以上是一种观察者，继承了观察者父类，实例化的时候可以自动将自己加入到被观察者中的观察者队列。

 protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //实例化被观察者
        Subject mySubject = new Subject();
        //实例化两个观察者
        new RedObserver(mySubject);
        new BlueObserver(mySubject);
        //被观察者状态改变--20
        mySubject.setState(20);
        Log.d("huankuai!","state changed!--20");
        Toast.makeText(this,"state changed --20",Toast.LENGTH_SHORT).show();
        //被观察者状态改变--30
        mySubject.setState(30);
        Log.d("huankuai!", "state changed!--30");
        Toast.makeText(this,"state changed --30",Toast.LENGTH_SHORT).show();
    }

实例化一个被观察者，两个观察者，当被观察在程序中改变状态时，调用观察者的回调函数，令观察者做出反馈。

观察者解点耦合

对具体的观察者可以改写一下，解除一点耦合，令观察者也可以只关心自己的动作与回调注册。

package com.example.listenertest;
 
public abstract class Observer {
    //添加被观察者的引用
    protected Subject subject;
    //更新的抽象方法
    public abstract void update();
    //监听被观察者
    public void addListener(Subject subject){
        this.subject = subject;
        subject.attach(this);
    }
}

以上可以看出，将监听被观察者的操作从具体的观察者类里转移到了抽象观察者类中。

package com.example.listenertest;
 
import android.util.Log;
 
public class BlueObserver extends Observer{
    public BlueObserver(){}
 
    @Override
    public void update() {
        Log.d("huankuai!","blue subject state: "+ this.subject.getState());
    }
}

以上可见，具体观察者类里无须实现监听操作，甚至看不出这个类属于观察者模式。

        //实例化两个观察者
        RedObserver red = new RedObserver();
        BlueObserver blue = new BlueObserver();
        red.addListener(mySubject);
        blue.addListener(mySubject);

当观察者实例化时，可以额外执行观察注册操作，代码更具有灵活性。