案例：

• 定义被观察者

/**
 * @author Gjing
 * 抽象被观察者
 **/
abstract class AbstractSubject {
    /**
     * 观察者对象的集合
     */
    private List<Listener> listenerList = new ArrayList<>();

    /**
     * 添加观察者
     *
     * @param listener 观察者
     */
    void add(Listener listener) {
        listenerList.add(listener);
    }

    /**
     * 通知所有观察者
     */
    void notifyObserver() {
        for (Listener listener : listenerList) {
            listener.update("通知所有观察者，按钮被点击。。。。。。");
        }
    }
}

/**
 * @author Gjing
 * 具体被观察者
 **/
class AbstractSubjectA extends AbstractSubject {
    void click() {
        System.out.println("按钮被点击");
        notifyObserver();
    }
}

• 定义观察者

/**
 * @author Gjing
 * 抽象观察者
 **/
public interface Listener {
    String getName();

    /**
     * 通知更新方法
     *
     * @param message 消息
     */
    void update(String message);
}

/**
 * @author Gjing
 * A观察者
 **/
class ListenerA implements Listener {
    @Override
    public String getName() {
        return "观察者A";
    }

    @Override
    public void update(String message) {
        System.out.println("观察者A收到消息更新：" + message);
    }
}

/**
 * @author Gjing
 * 观察者B
 **/
class ListenerB implements Listener {
    @Override
    public String getName() {
        return "观察者B";
    }

    @Override
    public void update(String message) {
        System.out.println("观察者B收到消息更新：" + message);
    }
}

• 调用

/**
 * @author Gjing
 **/
public class Test {
    public static void main(String[] args) {
        //创建被观察者
        AbstractSubjectA subjectA = new AbstractSubjectA();
        //添加观察者
        subjectA.add(new ListenerA());
        subjectA.add( new ListenerB());
        //被观察者行动
        subjectA.click();
    }
}

优点

1. 观察者和被观察者之间抽象耦合。观察者模式容易扩展，被观察者只持有观察者集合，并不需要知道具体观察者内部的实现。
2. 对象之间的保持高度的协作。当被观察者发生变化时，所有被观察者都会通知到，然后做出相应的动作。

缺点

1. 如果观察者太多，被观察者通知观察者消耗的时间很多，影响系统的性能。
2. 当观察者集合中的某一观察者错误时就会导致系统卡壳，因此一般会采用异步方式。

---

以上为个人理解，如有误欢迎各位指正