介绍

观察者模式采用一对多的方式，一是主题，多是指多个观察者，多个观察者监听了主题，如果主题发生变化，那么多个观察者就会收到通知，然后多个观察者再发生变化。

实例代码

抽象主题

public abstract class MyAbstractTitle {
    
    private List<MyObserver> list = new ArrayList<MyObserver>();
    
    public void addObserver(MyObserver observer) {
        list.add(observer);
    }
    
    public void delObserver(MyObserver observer) {
        list.remove(observer);
    }
    
    public void notifyObserver() {
        Iterator<MyObserver> its = list.iterator();
        
        while (its.hasNext()) {
            its.next().receiveInfo();
        }
    }
}

具体主题

public class MyConcreteTitle extends MyAbstractTitle{
    
    public void executeNotify() {
        notifyObserver();
    }
}

抽象观察者

public interface MyObserver {
    
    public void receiveInfo();
}

具体观察者

public class ObserverA implements MyObserver {

    @Override
    public void receiveInfo() {
        System.out.println("观察者A收到通知！");
    }
}

public class ObserverB implements MyObserver {

    @Override
    public void receiveInfo() {
        System.out.println("观察者B收到通知！");
    }
}

测试：

public static void main(String[] args) throws IOException {
    MyConcreteTitle mct = new MyConcreteTitle();
    MyObserver observerA = new ObserverA();
    MyObserver observerB = new ObserverB();
    mct.addObserver(observerA);
    mct.addObserver(observerB);
    mct.executeNotify();
}

说明：可以发现观察者相对于主题是动态添加的，主题中可以添加任意个观察者，观察者是委托给主题去执行的，相当于主题维护了一个可以增加删除的动态容器来盛装观察者，而主题本身会通知容器中所有的观察者；从而实现观察者模式。还可以发现一旦观察者添加到主题的容器中，不管是否需要都会被推送消息。

总结

观察者模式中，对于事先通知多少观察者，并不知情，所以观察者数量是不确定。所以说一个对象发生变化，而收到通知的观察者数量是多少是未知的。原因是你都知道是谁收到通知，那不就耦合了嘛！
适用于一对多的场景，一个发生变化，其他都收到通知也发生变化。
我们会发现，观察者与主题是解耦的，由于两个东西都和抽象的主题打交道，并不依赖于具体的对象。所以说其中任何一个发生变化，都不会影响其他对象。