定义

观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

结构

观察者模式的主要角色如下。

抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

类图

代码实现

抽象观察者Observer

public interface Observer {

    void response();

}

具体观察者1ConcreteObserver1

public class ConcreteObserver1 implements Observer{
    @Override
    public void response() {
        System.out.println("接收到通知，观察者1做出反应...");
    }
}

具体观察者1ConcreteObserver2

public class ConcreteObserver2 implements Observer{
    @Override
    public void response() {
        System.out.println("接收到通知，观察者2做出反应。。。");
    }
}

抽象目标Subject

public abstract class Subject {

    //保存所有观察者
    List<Observer> list;

    public Subject() {
        list = new ArrayList<>();
    }

    //添加观察者
    public void add(Observer observer) {
        list.add(observer);
    }

    //删除观察者
    public void remove(Observer observer) {
        list.remove(observer);
    }

    //抽象的通知观察者方法，留给子类实现
    public abstract void notifyObserver();
}

具体目标Concrete Subject

public class ConcreteSubject extends Subject{

    @Override
    public void notifyObserver() {
        List<Observer> observers = this.list;
        for (Observer observer: observers) {
            observer.response();
        }
    }
}

测试代码

public static void main(String[] args) {
    Observer observer1 = new ConcreteObserver1();
    Observer observer2 = new ConcreteObserver2();
    ConcreteSubject concreteSubject = new ConcreteSubject();
    concreteSubject.add(observer1);
    concreteSubject.add(observer2);
    concreteSubject.notifyObserver();
}

测试截图

模式的应用实例

利用观察者模式设计一个学校铃声的事件处理程序。

分析：在本实例中，学校的“铃”是事件源和目标，“老师”和“学生”是事件监听器和具体观察者，“铃声”是事件类。学生和老师来到学校的教学区，都会注意学校的铃，这叫事件绑定；当上课时间或下课时间到，会触发铃发声，这时会生成“铃声”事件；学生和老师听到铃声会开始上课或下课，这叫事件处理。这个实例非常适合用观察者模式实现，下图给出了学校铃声的事件模型。

现在用“观察者模式”来实现该事件处理模型。

定义一个铃声事件（RingEvent）类，它记录了铃声的类型（上课铃声/下课铃声）。
定义一个学校的铃（BellEventSource）类，它是事件源，是观察者目标类，该类里面包含了监听器容器 listener，可以绑定监听者（学生或老师），并且有产生铃声事件和通知所有监听者的方法。
定义铃声事件监听者（BellEventListener）类，它是抽象观察者，它包含了铃声事件处理方法 heardBell(RingEvent e)。
定义老师类（TeachEventListener）和学生类（StuEventListener），它们是事件监听器，是具体观察者，听到铃声会去上课或下课。图 4 给出了学校铃声事件处理程序的结构。

类图

代码实现

铃声事件RingEvent

public class RingEvent extends EventObject {

    //铃声的类型，true为上课铃，false为下课铃
    private boolean sound;

    public RingEvent(Object source, boolean sound) {
        super(source);
        this.sound = sound;
    }

    public boolean getSound() {
        return sound;
    }

    public void setSound(boolean sound) {
        this.sound = sound;
    }
}

铃声事件监听者BellEventListener

public interface BellEventListener {

    //该方法规定了当有铃声事件RingEvent传来时该怎么处理
    void heardBell(RingEvent event);

}

事件监听器老师类TeachEventListener

public class TeachEventListener implements BellEventListener{
    @Override
    public void heardBell(RingEvent event) {
        if(event.getSound()){
            System.out.println("老师上课了....");
        }else{
            System.out.println("老师下课了....");
        }
    }
}

事件监听器老师类StuEventListener

public class StuEventListener implements BellEventListener{
    @Override
    public void heardBell(RingEvent event) {
        if(event.getSound()){
            System.out.println("学生上课了...");
        }else{
            System.out.println("学生下课了...");
        }
    }
}

事件源BellEventSource

public class BellEventSource {

    List<BellEventListener> listeners;

    public BellEventSource(){
        listeners = new ArrayList<>();
    }

    //添加铃声事件
    public void addPersonListener(BellEventListener listener){
        listeners.add(listener);
    }

    //响铃
    public void ring(boolean sound){
        String type = sound?"上课铃":"下课铃";
        System.out.println(type+"响了！");
        RingEvent ringEvent = new RingEvent(this, sound);
        notifies(ringEvent);
    }

    //触发铃声事件
    public void notifies(RingEvent event){
        Iterator<BellEventListener> listenerIterator = listeners.iterator();
        while(listenerIterator.hasNext()){
            BellEventListener listener = listenerIterator.next();
            listener.heardBell(event);
        }
    }
}

测试代码

public static void main(String[] args) {
    //铃声（事件源）
    BellEventSource bellEventSource = new BellEventSource();

    //注册监听器（老师）
    bellEventSource.addPersonListener(new TeachEventListener());

    //注册监听器（学生）
    bellEventSource.addPersonListener(new StuEventListener());

    //打上课铃
    bellEventSource.ring(true);

    System.out.println("*************************************");

    //打下课铃声
    bellEventSource.ring(false);
}