多个对象间存在一对多关系，当一个对象发生改变时，把这种改变通知给其他多个对象，从而影响其他对象的行为
    观察者模式的别名包括发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。

    【角色】

    • 主题（Subject）：被观察者，它是指被观察的对象。处理观察者的变化。当它的状态发生改变时，向它的各个观察者发出通知。
    • 具体主题（ConcreteSubject）：是一个实现主题接口的类，有一个用来存放观察者对象的容器。
    • 观察者（Observer）：根据主题中的更改而进行更新，观察者一般定义为接口，该接口声明了更新数据的方法 update()，因此又称为抽象观察者。
    • 具体观察者（ConcreteObserver）：具体观察者的实现类。

    【优点】

    • 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系，符合“开闭原则”的要求

    【缺点】

    • 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。

    • 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

      1. /**
      2. * 观察者接口
      3. */
      4. public interface Observer {
      5.   void update(String message);
      6. }
      1. /**
      2. * 观察者类
      3. */
      4. public class ConcreteObserver implements Observer {
      6.   private String name;
      8.   public ConcreteObserver(String name) {
      9.       this.name = name;
      10.   }
      12.   @Override
      13.   public void update(String message) {
      14.       System.out.println(name + " 收到了动态：" + message);
      15.   }
      16. }
      1. /**
      2. * 主题抽象类
      3. */
      4. public interface Subject {
      6.   /**
      7.    * 添加观察者
      8.    * @param observer
      9.    */
      10.   void add(Observer observer);
      12.   /**
      13.    * 移除观察者
      14.    * @param observer
      15.    */
      16.   void remove(Observer observer);
      18.   /**
      19.    * 通知所有观察者
      20.    * @param message
      21.    */
      22.   void notify(String message);
      23. }
      1. /**
      2. * 主题类
      3. */
      4. public class ConcreteSubject implements Subject {
      6.   private List<Observer> observerList = new ArrayList<>();
      8.   /**
      9.    * 添加观察者
      10.    * @param observer
      11.    */
      12.   @Override
      13.   public void add(Observer observer) {
      14.       observerList.add(observer);
      15.   }
      17.   /**
      18.    * 移除观察者
      19.    * @param observer
      20.    */
      21.   @Override
      22.   public void remove(Observer observer) {
      23.       observerList.remove(observer);
      24.   }
      26.   /**
      27.    * 通知所有观察者
      28.    * @param message
      29.    */
      30.   @Override
      31.   public void notify(String message) {
      32.       for (Observer observer : observerList) {
      33.           observer.update(message);
      34.       }
      35.   }
      36. }

      ```java public class ObserverTest { public static void main(String[] args) {

      1.   // 观察者
      2.   Observer observer1 = new ConcreteObserver("张三");
      3.   Observer observer2 = new ConcreteObserver("李四");
      4.   Observer observer3 = new ConcreteObserver("王五");
      6.   // 主题
      7.   Subject subject = new ConcreteSubject();
      8.   subject.add(observer1);
      9.   subject.add(observer2);
      10.   subject.add(observer3);
      11.   subject.notify("第一条朋友圈");
      13.   System.out.println();
      15.   subject.remove(observer3);
      16.   subject.notify("第二条朋友圈");

      } } ——输出—— 张三 收到了动态：第一条朋友圈 李四 收到了动态：第一条朋友圈 王五 收到了动态：第一条朋友圈

    张三 收到了动态：第二条朋友圈 李四 收到了动态：第二条朋友圈 ```