定义

观察者模式(Observer Pattern)：定义对象之间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式的别名包括发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。

通俗理解

“敌不动，我不动，敌若动，我先动”，这是《兵法》一个经典的战略，意思是说，在战场上，我们要注意好敌军的动向，根据敌军的动向来指定自己这一方的作战方针，如果敌人不行动，我们就按兵不动，如果敌人行动，我们就需要比敌人更先行动。这一句话后来被毛泽东融合当时在社会斗争情况总结为"敌来我走，敌驻我扰，敌退我追"！这也是根据敌人的行动来执行自己的战略。

类似于这种，根据敌人的行动类改变自己的方针，就是观察者模式最好的诠释。当敌人行动的时候，他的状态改变了，那么也会影响到我军的状态。当然，在观察者模式当中，定义的是一对多的依赖关系，这在生活中的含义就是，当一军行动的时候，会引起联合军队的行动。

这样的例子，不仅仅存在战场上，在我们生活中也是如此。红绿灯变绿的时候，所有的汽车都会开动；当号令枪响的时候，所有的运动员都会健步如飞；当下暴雨的时候，所有的人都会躲雨。

示例

业务为红绿灯变绿的时候，所有的汽车都会开动。

渣渣程序

红绿灯

public class TrafficLight {
    private ELightType eLightType;
    private Car car;
    public TrafficLight(Car car) {
        this.car = car;
    }
    public void becomeGreen() {
        eLightType = ELightType.GREEN;
        System.out.println("交通灯变绿了"+eLightType);
    }
    public void becomeYellow() {
        eLightType = ELightType.YELLOW;
        System.out.println("交通灯变黄了"+eLightType);
    }
    public void becomeRed() {
        eLightType = ELightType.RED;
        System.out.println("交通灯变红了"+eLightType);
    }
    public void notifyCar() {
        switch (eLightType) {
            case RED:car.stop();break;
            case GREEN:car.move();break;
            case YELLOW:car.stop();break;
            default:car.stop();
        }
    }
    public enum ELightType {
        GREEN,YELLOW,RED
    }
}

车辆

public class Car {
    private boolean isMove = false;
    //setter、getter方法省略
    public void move() {
        isMove = true;
        System.out.println("汽车开动了"+isMove);
    }
    public void stop() {
        isMove = false;
        System.out.println("汽车停止了"+isMove);
    }
}

程序入口

public class Main {
    public static void main(String[] args) {
        TrafficLight trafficLight = new TrafficLight(new Car());
        trafficLight.becomeGreen();
        trafficLight.notifyCar();
    }
}
//交通灯变绿了GREEN
//汽车开动了true

上面基本上是实现了观察者模式的理念，但是演示了什么叫不面向接口编程，什么叫紧耦合。存在如下问题：

红绿灯和车辆是紧耦合的，如果我需要添加行人监听，那么我就需要修改交通灯的类，不利于扩展；
车辆（订阅者）的类的更新方法复杂，没有统一接口，如果添加行人的更新状态根本是不可能的。
这里提示车辆更新的方法只传递了一个类型，如果这个类型十分复杂的情况下，那么参数很难搞定。

优化

类图

程序

观察者接口与车辆实现

public interface IObserver {
    void update(ISubject subject, Object args);
}
public class Car implements IObserver {
    private boolean isMove = false;
    // 省略setter、getter方法
    public void move() {
        isMove = true;
        System.out.println("汽车开动了"+isMove);
    }
    public void stop() {
        isMove = false;
        System.out.println("汽车停止了"+isMove);
    }
    @Override
    public void update(ISubject subject, Object args) {
        TrafficLight.ELightType type = (TrafficLight.ELightType) args;
        update(type);
    }
    public void update(TrafficLight.ELightType type) {
        switch (type) {
            case RED:stop();break;
            case GREEN:move();break;
            case YELLOW:stop();break;
            default:stop();
        }
    }
}

被观察对象的接口与交通灯实现

public interface ISubject {
    void addObserver(IObserver observer);
    void removeObserver(IObserver observer);
    void removeObservers();
    void notifyObservers(Object args);
    void notifyObservers();//模式里面没有这个方法
}
public class TrafficLight implements ISubject{
    private LinkedTransferQueue<IObserver> observers;
    public TrafficLight() {
        this.observers = new LinkedTransferQueue<>();
    }
    private ELightType eLightType;
    public ELightType geteLightType() {
        return eLightType;
    }
    public void seteLightType(ELightType eLightType) {
        this.eLightType = eLightType;
    }
    public void becomeGreen() {
        eLightType = ELightType.GREEN;
        System.out.println("交通灯变绿了"+eLightType);
    }
    public void becomeYellow() {
        eLightType = ELightType.YELLOW;
        System.out.println("交通灯变黄了"+eLightType);
    }
    public void becomeRed() {
        eLightType = ELightType.RED;
        System.out.println("交通灯变红了"+eLightType);
    }
    @Override
    public void addObserver(IObserver observer) {
        this.observers.add(observer);
    }
    @Override
    public void removeObserver(IObserver observer) {
        this.observers.remove(observer);
    }
    @Override
    public void removeObservers() {
        this.observers.clear();
    }
    @Override
    public void notifyObservers(Object args) {
        for(IObserver observer : observers) {
            observer.update(this, args);
        }
    }
    @Override
    public void notifyObservers() {
        notifyObservers(eLightType);
    }
    public enum ELightType {
        GREEN,YELLOW,RED
    }
}

程序入口

public class Main {
    public static void main(String[] args) {
        ISubject trafficLight = new TrafficLight();
        IObserver car = new Car();

        trafficLight.addObserver(car);
        ((TrafficLight) trafficLight).becomeGreen();
        trafficLight.notifyObservers();
    }
}
//交通灯变绿了GREEN
//汽车开动了true

通过上面的过程，如果我们需要添加一个新的订阅者，那么只需要添加一个新的订阅者并实现IObserver，然后写上相关的update方法就可以，而且这种方式可以增加多个订阅者，不像一开始一样，就只能绑定一个订阅者。