详解观察者（Observer）模式

观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

Observer观察者模式目录

1 观察者接口;
2 被观察者;
3 观众类;
4 电影类;
5 效果如下;

观察者接口

    package ObserverModel;
   /**
    * 观察者，定义update方法，意为接收从被观察者那里反馈的信息
   */
   public interface Observer {
       /**
        * @param message 接收的信息，可以是任意类型，这里是String
        */
   void update(String message);
   }

被观察者

   package ObserverModel;
   /**
    * 抽象接口被观察者，比如微信公众号或者电影等
    */
   public interface Observerable {
       /**
        * 注册一个新的观察者
        *
        * @param observer 观察者
        */
       void registerObserver(Observer observer);
       /**
        * 删除观察者
        *
        * @param observer 观察者
        */
       void removeObserver(Observer observer);
       /**
        * 通知观察者
        */
       void notifyObserver();
   }

观众类

   package ObserverModel;
   /**
    * 观众 实现观察者接口
    */
   public class Audience implements Observer {
       //名字
       private String name;
       //收到的信息
       private String message;
       Audience(String name) {
           this.name = name;
       }
       @Override
       public void update(String message) {
           this.message = message;
           watch(message);
       }
       /**
        * 打印被观察者发出的信息
        *
        * @param information 信息
        */
       void watch(String information) {
           System.out.println(name + "看到了：" + message);
       }
   }

电影类

   package ObserverModel;
   import java.util.ArrayList;
   import java.util.List;
   /**
    * 电影类
    */
   public class Movie implements Observerable {
       /**
        * 观众，这里就是观察者
        */
       private List observers;
       Movie() {
           this.observers = new ArrayList();
       }
       /**
        * 被观察者传递出的信息，比如剧情，画面等
        */
       private String information;
       /**
        * 有人来看电影，添加一个观察者
        *
        * @param observer 观察者
        */
       @Override
       public void registerObserver(Observer observer) {
           observers.add(observer);
       }
       /**
        * 观众走了，从观众中移除
        *
        * @param observer 观察者
        */
       @Override
       public void removeObserver(Observer observer) {
           if (observers.size() > 0) {
               observers.remove(observer);
           }
       }
       /**
        * 这里的notifyObserver可以理解为向观察者传递信息，比如看电影就是再从电影中获取信息
        */
       @Override
       public void notifyObserver() {
           observers.forEach(observer -> {
               observer.update(information);
           });
       }
       /**
        * 被观察者生产消息时，给所有观察者发送通知
        * @param information
        */
       public void setInformation(String information) {
           this.information = information;
           notifyObserver();
       }
   }

效果如下

   package ObserverModel;
   public class MainTest {
       public static void main(String[] args) {
           //泰坦尼克号
           Movie titanic = new Movie();
           Observer zhangsan = new Audience("张三");
           Observer lisi = new Audience("李四");
           Observer wangwu = new Audience("王五");
           titanic.registerObserver(zhangsan);
           titanic.registerObserver(lisi);
           titanic.registerObserver(wangwu);
           titanic.setInformation("jack is dead!");
           //oh no ,太虐了，不看了！
           titanic.removeObserver(wangwu);
           titanic.setInformation("rose not dead!");
       }
   //    张三看到了：jack is dead!
   //    李四看到了：jack is dead!
   //    王五看到了：jack is dead!
   //    张三看到了：rose not dead!
   //    李四看到了：rose not dead!
   }