观察者模式适用于以下情形：当有一个对象要向外界发出信息，有一些对象需要对这个信息进行实时的接收。
使用观察者模式我们可以方便的进行观察者的增添和删除工作而不需要对消息发送方进行任何的改变。

遵循的设计原则

1. 面相接口编程
   这样我们在写调用的时候就不需要知道具体要调用哪个对象，而是说满足某种条件的对象（即实现了这个接口的对象）来做这件事，相当于将对象重新抽象了一下。这样的好处是当增添新的对象的时候，代码不需要更改。
2. 为了交互对象之间的松耦合而努力
   意思是让对象之间的相互依赖程度降到最低，也就是在对象内部少进行对于另一个对象的调用

如何实现

观察者模式有两类角色：消息发送方subject， 消息接收方observer
这里subject和observer指的不是一个对象而是一类对象，所以我们创建两个接口subject和observer
subject（消息发送方）：
我们在subject中添加了register（）和remove（）方法，方便对observer列表进行管理，同时添加notify（）方法对列表中所有的observer进行通知更新操作。
observer（消息接收方）：
observer中我们只需要预留update（）方法使得subject可以给我们通知。

类图

网图。。侵删。。

实战演练

/**
 * Created by LeafEater on 2017/2/7.
 * 设计模式：ObserverPatterns
 * 需求：我们有一个观察站，可以从传感器中获得实时温度信息，我们需要创造三个展示板。
 * 每个展示板都有不同的功能，有的实时显示数据，有的预测未来走向，有的用来将信息转发给电视台
 * 以后可能会有新的布告板所以要方便添加
 */
public class WeatherStation {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay conditionsDisplay = new CurrentConditionsDisplay(weatherData);
        weatherData.setMeasurements(12,24,35);
    }
}

interface Subject{
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObserver();
}

interface Observer{
    void update(float temp, float humidity, float pressure);
}

interface DisplayElement{
    void display();
}

/**
 * 在这个例子中WeatherData负责推送消息，也就是subject
 */
class WeatherData implements Subject{
    private ArrayList<Observer> observers;
    private float temperature;
    private float humidity;
    private float pressure;

    WeatherData() {
        this.observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        int i = observers.indexOf(o);
        if(i >= 0) observers.remove(o);
    }

    @Override
    public void notifyObserver() {
        for(int i = 0;i<observers.size();i++){
            Observer observer = observers.get(i);
            observer.update(temperature,humidity,pressure);
        }
    }

    public void measurementsChanged(){
        notifyObserver();
    }

    public void setMeasurements(float temperature, float humidity, float pressure){
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }

}

/**
 * 其中一个布告板的实现
 * 布告板实时显示温度，气压，湿度
 * 每个布告板都是一个observer
 */
class CurrentConditionsDisplay implements Observer , DisplayElement{
    private float temperature;
    private float humidity;
    private float pressure;
    private Subject weatherData;

    public CurrentConditionsDisplay(Subject weatherData){
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }
//  每当数据更新的时候我们将更新数据显示出来
    public void update (float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        display();
    }

    @Override
    public void display() {
        System.out.println("weather:"+"temperature:"+temperature+"humidity:"
                +humidity+"pressure:"+pressure);
    }
}

运行结果：

weather:temperature:12.0humidity:24.0pressure:35.0

总结一下

通过这个例子我们可以更好的理解接口的作用，在这个例子中，Subject中维护了一个包含若干的布告板（CurrentConditionsDisplay ）的list，但是布告板是一个随时有可能增加减少的对象。这里我们分析出Subject在使用具体的布告板的时候只是使用，Update()方法，这时候我们将Observer抽象出来，使得Subject持有的是超类的引用，将Subject与Observer的耦合程度降到了最低（即只依赖其中的一个方法）。