【南京校区】常见的设计模式--观察者模式(Observer)

- 概述:在javaweb阶段,我们会学习到Listener,它是基于观察者模式设计的.

- 观察者模式又叫做发布-订阅(Publish/Subsribe)模式

        观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象.
        这个主题对象在状态发生变化时,会通知所有观察者对象,使它们能够自动更新自己.
   
        观察者模式结构图
   
   
   
        具体代码设计
        1.定义两个接口(或抽象类),分别是观察者和被观察者
        /**
         * 被观察者
         */
        public interface Observable {
        
            /**
             * 添加观察者
             * @param observer
             */
            public void addObserver(Observer observer);
            
            /**
             * 移除观察者
             * @param observer
             */
            public void removeObserver(Observer observer);
            
            /**
             * 通知观察者
             * @param str
             */
            public void notifyObserver(String str);
        }

   
        /**
         * 观察者
         */
        public interface Observer {
        
            /**
             * 获得被观察的变化
             * @param str
             */
            public void update(String str);
        }

   
        2.写两类实现观察者和被观察者的接口
        /**
         * 创建被观察者实体类
         */
        public class ConcreteObservable implements Observable{
        
            //创建一个集合保存观察者
            private List<Observer> observerList = new ArrayList<>();
            
            @Override
            public void addObserver(Observer observer) {
                //添加观察者到集合
                observerList.add(observer);
            }
        
            @Override
            public void removeObserver(Observer observer) {
                //从集合中移除观察者
                observerList.remove(observer);
            }
        
            @Override
            public void notifyObserver(String str) {
                //通知集合中的每一个观察者
                for (int i = 0; i < observerList.size(); i++) {
                    Observer observer = observerList.get(i);
                    observer.update(str);
                }
            }
        }   

        
        /**
         * 创建观察者实体类
         */
        public class ConcreteObserver implements Observer {
        
            @Override
            public void update(String str) {
                System.out.println("收到通知: " + str);
            }
        }

   
        3.编写测试类
        public class Test {
            public static void main(String[] args) {
                //创建被观察者对象
                Observable observable = new ConcreteObservable();
               
                //创建观察者
                Observer observer1 = new ConcreteObserver();
                Observer observer2 = new ConcreteObserver();
                Observer observer3 = new ConcreteObserver();
               
                //添加观察者
                observable.addObserver(observer1);
                observable.addObserver(observer2);
                observable.addObserver(observer3);
               
                //通知所有观察者
                observable.notifyObserver("进来按摩吧...");
               
                System.out.println("===============================");
               
                //移除一个观察者
                observable.removeObserver(observer1);
                observable.notifyObserver("刚刚走了一个...");
            }
        }

- java中内置的观察者模式

        java中的内置观察者模式有两个类：一个是Observable被观察者类，一个是Observer观察者接口。
        注意：调用notifyObservers()方法之前，必须先调用setChanged()方法。

        具体代码实现:
        1.创建观察者和被观察者的具体实现类
        /**
         * 创建一个被观察者的实现类
         */
        public class MyObservable extends Observable {
            @Override
            protected synchronized void setChanged() {
                super.setChanged();
            }
        }

        /**
         * 创建一个观察者的实现类
         */
        public class MyObserver implements Observer {
            @Override
            public void update(Observable o, Object arg) {
                System.out.println(o.getClass().getSimpleName() + "====获得update====" + arg);
            }
        }

        2.创建测试类
        public class Test {
            public static void main(String[] args) {
                //创建被观察者对象
                MyObservable observable = new MyObservable();
                //创建观察者对象
                Observer observer = new MyObserver();
                //添加观察者
                observable.addObserver(observer);
                //调用notifyObservers方法之前,必须先调用setChanged()方法
                observable.setChanged();
                //通知所有的观察者
                observable.notifyObservers("hahaha");
            }
        }

可以把设计模式好好总结一下

666设计模式一直是代码中很绕的地方 感谢分享

解决了我的苦恼很久的问题啊~~

666，学习了。

6666666