Java设计模式之一：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!
    }