观察者模式

• 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。（优点）
• 目标与观察者之间建立了一套触发机制。（优点）
• 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。（缺点）
• 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。（缺点）

• 对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。
• 当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

• 主题

public class Subject {
      
      private List<Observer> observers = new ArrayList<>();
      
      private int state;
      
      public int getState() {
          return state;
      }
      public void setState(int state) {
          this.state = state;
          notifyAllObservers();
      }
      public void add(Observer observer) {
          observers.add(observer);
      }
      public void remove(Observer observer) {
          observers.remove(observer);
      }
      public void notifyAllObservers() {
          for (Observer observer : observers) {
              observer.update();
          }
      }
  }

• 抽象观察者和具体观察者

//抽象观察者
  public abstract class Observer {
      protected Subject subject;
      public abstract void update();
  }

  //具体观察者
  public class BinaryObserver extends Observer {
      public BinaryObserver(Subject subject) {
          this.subject = subject;
          this.subject.add(this);
      }
      @Override
      public void update() {
          String result = Integer.toBinaryString(subject.getState());
          System.out.println("数据处理为二进制值为：" + result);
      }
  }
  public class HexaObserver extends Observer {
      public HexaObserver(Subject subject) {
          this.subject = subject;
          this.subject.add(this);
      }
      @Override
      public void update() {
          String result = Integer.toHexString(subject.getState()).toUpperCase();
          System.out.println("数据处理为十六进制值为：" + result);
      }
  }

• 测试

public static void main(String[] args) {
      Subject subject =new Subject();
      new BinaryObserver(subject);
      new HexaObserver(subject);
      subject.setState(100);
  }