观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个通知者对象。这个通知者对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己

结构图

观察者模式

简单实现

package observer;

/**
 * 通知者接口
 */
public interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObserver();
}

/**
 * 观察者接口
 */
public interface Observer {
    void update();
}

package observer;

import java.util.ArrayList;
import java.util.List;

/**
 * 具体通知者的实现
 */
public class ConcreteSubject implements Subject{
    List<Observer> observers = new ArrayList<Observer>();
    private String state;

    public void setState(String state) {
        this.state = state;
        notifyObserver();
    }

    public String getState() {
        return state;
    }

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void detach(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObserver() {
        for (Observer observer:observers){
            observer.update();
        }
    }
}

package observer;

/**
 * 观察者的实现A
 */
public class ConcreteObserverA implements Observer{
    private ConcreteSubject subject;
    private String name;

    public ConcreteObserverA(ConcreteSubject subject, String name) {
        this.subject = subject;
        this.name = name;
    }

    public void update() {
        System.out.println(subject.getState()+","+name+"赶紧看书");
    }
}

package observer;

/**
 * 观察者的实现B
 */
public class ConcreteObserverB implements Observer{
    private ConcreteSubject subject;
    private String name;

    public ConcreteObserverB(ConcreteSubject subject, String name) {
        this.subject = subject;
        this.name = name;
    }

    public void update() {
        System.out.println(subject.getState()+","+name+"赶紧写作业");
    }
}

package observer;

public class Client {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        ConcreteObserverA observerA = new ConcreteObserverA(subject,"小明");
        ConcreteObserverB observerB = new ConcreteObserverB(subject,"小红");

        subject.attach(observerA);
        subject.attach(observerB);

        subject.setState("老师来了");
    }
}

输出:
老师来了,小明赶紧看书
老师来了,小红赶紧写作业

特点

动机

将一个系统分割成一系列相互协作的类有一个很不好的副作用,那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便。而观察者的关键对象时通知者Subject和观察者Observer，一个Subject可以有任意数目的依赖它的Observer，一旦Subject的状态发生了改变，所有Observer都可以得到通知。Subject法术通知时并不需要知道谁是它的观察者，也就是说，具体观察者是谁，它根本不需要知道。而任何一个具体观察者不知道耶不需要知道其他观察者的存在。

什么时候使用

• 当一个对象的改变需要同时改变其他对象的时候。而且它不知道具体有多少对象有待改变时，应该考虑使用观察者模式。
• 当一个模型有两个方面，其中一方面依赖于另一方面，这时用观察者模式可以将这两者封装在独立地对象中使它们各自独立地改变和复用。

小结

观察者模式所做的工作其实就是在解除耦合。让耦合双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。