设计模式02-观察者者设计模式

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/wdd1324/article/details/82219737

设计模式02-观察者者设计模式

主要来源Head First设计模式(书)
观察者设计模式是JDK中使用最多的设计模式之一

如果你了解报纸订阅是怎么回事,其实就知道观察者模式是怎么回事,知识名称不一样:出版社改为主题(Subject),订阅者改为观察者(Observer)

书中定义:对象之间的一对多依赖,这样一来,当一个对象改变状态时,它的所有依赖者都会收到通知并自动更新。

案例分析

用户订阅报纸

1. 主题

    /**
     * 类描述:主题<br/>
     */
    interface Subject{
        //主题需要几个方法
        //添加观察者
        fun addObserver(observer: Observer)
        //删除观察者
        fun removeObserver(observer: Observer)
        //通知观察者
        fun notifyObserver(t: Any)
    }

2.观察者

    /**
     * 类描述:观察者<br/>
     */
    interface  {
        //一种观察者接收的数据应该是一样的所以可以添加泛型
        //更新数据
        fun<T> update(t: T)
    }

3.具体主题

    /**
     * 类描述:具体主题<br/>
     */
    class ConcreteSubject: Subject{
        /**
         * 观察者集合
         */
        private val mObserver by lazy {
            mutableListOf<Observer>()
        }

        override fun addObserver(observer: Observer) {
            mObserver.indexOf(observer)
                    .takeIf {
                        it == -1
                    }?.let {
                         mObserver.add(observer)
                    }
        }

        override fun removeObserver(observer: Observer) {
            mObserver.indexOf(observer)
                    .takeIf {
                        it > -1
                    }?.let {
                        mObserver.remove(observer)
                    }
        }

        override fun notifyObserver(t: Any) {
            mObserver.forEach {
                it.update(t)
            }
        }
    }

4.具体观察者

    /**
     * 类描述:具体观察者<br/>
     */
    class ConcreteObserver1 : Observer {
        override fun <报纸内容> update(t: 报纸内容) {
            Log.d("123===", "1,当前报纸内容是$t")
        }
    }

    /**
     * 类描述:具体观察者<br/>
     */
    class ConcreteObserver2 : Observer {
        override fun <报纸内容> update(t: 报纸内容) {
            Log.d("123===", "2,当前报纸内容是$t")
        }
    }

    /**
     * 类描述:具体观察者<br/>
     */
    class ConcreteObserver3 : Observer {
        override fun <报纸内容> update(t: 报纸内容) {
            Log.d("123===", "3,当前报纸内容是$t")
        }
    }

接收对象

    /**
     * 类描述:报纸内容<br/>
     */
    data class 报纸内容(val name: String, val content: String)

5.使用

        val a1 = 报纸内容("我是1", "haha1")
        val a2 = 报纸内容("我是2", "hehe2")
        val a3 = 报纸内容("我是3", "heihei3")

        val o1 = ConcreteObserver1()
        val o2 = ConcreteObserver2()
        val o3 = ConcreteObserver3()

        val subject = ConcreteSubject()

        subject.addObserver(o1)
        subject.addObserver(o2)
        subject.addObserver(o3)

        subject.notifyObserver(a1)
        subject.notifyObserver(a2)

        subject.removeObserver(o3)

        subject.notifyObserver(a3)

6.结果

    1,当前报纸内容是报纸内容(name=我是1, content=haha1)
    2,当前报纸内容是报纸内容(name=我是1, content=haha1)
    3,当前报纸内容是报纸内容(name=我是1, content=haha1)
    1,当前报纸内容是报纸内容(name=我是2, content=hehe2)
    2,当前报纸内容是报纸内容(name=我是2, content=hehe2)
    3,当前报纸内容是报纸内容(name=我是2, content=hehe2)
    1,当前报纸内容是报纸内容(name=我是3, content=heihei3)
    2,当前报纸内容是报纸内容(name=我是3, content=heihei3)

7.UML图

uml下载地址

观察者模式-01

第四个设计原则

为了交互对象之间的松耦合设计而努力。

第1.2.3设计原则(GitHub地址)

为什么:松耦合的设计之所以能让我们建立有弹性的OO系统,能够应对变化,是因为对象之间的互相依赖降到最低。

JAVA内置了观察者模式

java.util.Observable->这是一个类不是接口,从这可以看到其缺点。
java.util.Observer

猜你喜欢

转载自blog.csdn.net/wdd1324/article/details/82219737