23种设计模式之观察者模式(12)

• 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态发生变化时会通知所有观察者对象，使他们能够自动更新自己。
• 将一个系统分割成一系列相互协作的类有一个很不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便。
• 观察者模式的使用场景：当一个对象的改变需要同时改变其他对象。而且他不知道具体有多少对象有待改变是应该考虑使用观察者模式。
• 一个抽象模型有两个方面，其中一方面依赖于另一方面，这时用观察者模式可以将这两者封装在独立的对象中使他们各自独立的改变和复用。
• 观察者模式所做的工作其实就是在解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而是的各自的变化都不会影响另一边的变化。

• Observe.java

  /**
   * 某一观察者
   */
  public abstract class Observer {
      /**
       * 在被通知后，发生变更
       */
      public abstract void update();
  }
  

• ConcreteObserver.java

  /**
   * 具体观察者
   */
  public class ConcreteObserver extends Observer {
  
      private String name;
      private String observerState;
      private ConcreteSubject subject;
  
      public ConcreteObserver(String name, ConcreteSubject subject) {
          this.name = name;
          this.subject = subject;
      }
  
      public ConcreteSubject getSubject() {
          return subject;
      }
  
      public void setSubject(ConcreteSubject subject) {
          this.subject = subject;
      }
  
      @Override public void update() {
          observerState = subject.getSubjectStatus();
          System.out.println("观察者"+name+"的新状态是"+observerState);
          System.out.println(name+"收起了手机");
      }
  }
  

• Subject.java

  /**
   * 通知者接口
   */
  public class Subject {
      private List<Observer> observers = new ArrayList<>();
  
      //增加观察者
      public void attach(Observer observer) {
          observers.add(observer);
      }
  
      //移除观察者
      public void detach(Observer observer) {
          observers.remove(observer);
      }
  
      //通知
      public void notify1() {
          for (Observer observer: observers) {
              observer.update();
          }
      }
  }
  

• ConcreteSubject.java

  /**
   * 具体通知者
   */
  public class ConcreteSubject extends Subject {
      private String subjectStatus;
      //具体被观察者状态
  
      public String getSubjectStatus() {
          return subjectStatus;
      }
  
      public void setSubjectStatus(String subjectStatus) {
          this.subjectStatus = subjectStatus;
      }
  }
  

• ObersverMian.java

  public class ObersverMian {
      public static void main(String[] args) {
          final ConcreteSubject s = new ConcreteSubject();
          s.attach(new ConcreteObserver("X",s));
          s.attach(new ConcreteObserver("Y",s));
          s.attach(new ConcreteObserver("Z",s));
  
          s.setSubjectStatus("ABC");
          s.notify1();
      }
  }
  

• 执行结果

  观察者X的新状态是ABC
  X收起了手机
  观察者Y的新状态是ABC
  Y收起了手机
  观察者Z的新状态是ABC
  Z收起了手机
  

• 事件委托

• 委托就是一种引用方法的类型。一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以向其他任何方法一样，具有参数和返回值。委托可以看作是对函数的抽象，是函数的‘类’，委托的实例将代表一个具体的函数。

• 一个委托可以搭载多个方法，所有方法被依次唤起。它可以使得委托对象搭载的方法并不需要属于同一个类。

• 委托的前提：委托对象所搭载的所有方法必须具有相同的原型和形式，也就是拥有相同的参数列表和返回值类型。