观察者模式

定义

观察者模式：定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖它的对象都会得要通知并自动更新。

意义

此设计模式最重要的作用就是解耦，将观察者与被观察者解耦，使得他们之间的依赖性更小

UML图

image

• Subject:就是“被观察”的角色，它将所有观察者对象的引用保存在一个集合中
• Observer：就是抽象的“观察”角色，它定义了一个更新接口，使得在被观察者状态发生改变的时候通知自己
• ObserverOne、ObserverTwo：具体的观察者

实现

1.被观察者Subject对象

class Subject {
    val observers = arrayListOf<Observer>()
    var state:String? = null
    set(value){
        field = value
        notifyObservers()
    }
    fun attach(observer:Observer){
        observers.add(observer)
    }

    fun detach(observer:Observer){
        observers.remove(observer)
    }

    fun notifyObservers(){
        observers.forEach{
            it.update(state)
        }
    }
}

2.观察者Observer对象
首先是一个接口，抽象出了一个及时更新的方法

interface Observer {
    fun update(state:String?)
}

接着是观察者ObserverOne、ObserverTwo对象

class ObserverOne :Observer{
    override fun update(state: String?) {
        println("ObserverOne接收到消息：$state")
    }
}

class ObserverTwo:Observer {
    override fun update(state: String?) {
        println("ObserverTwo接收到消息：$state")
    }
}

测试类

    fun main(){
        val subject = Subject()
        val observerOne = ObserverOne()
        val observerTwo = ObserverTwo()

        subject.attach(observerOne)
        subject.attach(observerTwo)

        subject.state = "Hello Observer"

    } 

结果

ObserverOne接收到消息：Hello Observer
ObserverTwo接收到消息：Hello Observer

open class SubjectFather {
    val observers = arrayListOf<Observer>()

    fun attach(observer:Observer){
        observers.add(observer)
    }

    fun detach(observer: Observer){
        observers.remove(observer)
    }

    fun notifyObservers(obj:String?){
        observers.forEach{
            it.update(obj)
        }
    }
}

接着一个具体的被观察者对象

class SubjectOne:SubjectFather() {
    var state:String? = null
    set(value) {
        field = value
        notifyObservers(state)
    }
}