前言

上一篇提到了Kotlin的单例模式（传送门https://www.jianshu.com/p/9e2d584e6a85），本篇主要涉及其他的设计模式，大部分与java的写法一致，像工厂和抽象工厂等一系列的跟java写法是一样所以没有列举出来，只是java代码转换为Kotlin代码。在使用的时候根据具体场景使用就行。

1.建造者模式

建造者模式是为了构建复杂而且多变的实例，Kotlin中使用apply函数实现

val dialog = Dialog(this).apply {
        setTitle("kotlin")
        setCancelable(true)
        setCanceledOnTouchOutside(true)
        //show()
    }

在apply函数里面可以直接调用show()方法，如果希望构建实例和其他无关的操作分开，可以使用Type-Safe Builders

class Student (
            val model: String?,
            val year: Int
    ) {
        private constructor(builder: Builder) : this(builder.model, builder.year)

        class Builder {
            var model: String? = null
            var year: Int = -1

            fun build() = Student(this)
        }

        companion object {
            inline fun build(block: Builder.() -> Unit) = Builder().apply(block).build()
        }
    }

    // usage
    val student = Student.build {
        model = "Heweii"
        year = 1993
    }

2.原型模式

原型模式是以一个对象为原型，创建出一个新的对象。Kotlin因为使用 data class 时，会自动获得equals、hashCode、toString和copy方法，相对java简便很多，copy方法可以克隆整个对象并且允许修改新对象某些属性。

data class Film(var name: String, var content: String?, var actorList: String?)

    val film = Film("西游记", "。。。", "六小龄童。。。")
    val copy = film.copy(name = "西游记2")

3.适配器模式

Kotlin的实现方式和java类似

interface Target {
    fun request()
}

interface Adaptee {
    fun setView()
}

class Adapter(val wrapper: Adaptee) : Target {
    override fun request() {
        wrapper.setView()
    }
}

4.装饰模式

kotli中独有的扩展函数可以很简便的做到装饰模式

class Text(val text: String) {
    fun draw() = print(text)
}

fun Text.underline(decorated: Text.() -> Unit) {
    print("_")
    this.decorated()
    print("_")
}

// usage
Text("Hello").run {
    underline {
        draw()
    }
}

5.职责链模式

职责链模式通过建立一条链来组织请求的处理者，请求将沿着链进行传递，请求发送者无须知道请求的去向，实现了请求发送者与处理者的解耦。Kotlin 与java是一样的处理方式

interface EventHandler {
    var next: EventHandler?
    fun handle(event: MotionEvent): Boolean
}

open class View : EventHandler {
    override var next: EventHandler? = null
    override fun handle(event: MotionEvent): Boolean {
        return onTouchEvent()
    }
    open fun onTouchEvent() : Boolean { 
        ...
        return false 
    }
}

open class ViewGroup : View() {
    override fun handle(event: MotionEvent): Boolean {
        if (onInterceptTouchEvent(event)) return onTouchEvent()
        else return next?.handle(event)!!
    }
    
    open fun onInterceptTouchEvent(event: MotionEvent): Boolean { // 是否拦截事件
        ...
        return false
    }
}

6.迭代器模式

迭代器模式提供一种遍历聚合对象中的元素的一种方式。Kotlin 中定义 operator fun iterator() 迭代器函数，或者是作为扩展函数时，可以在 for 循环中遍历。

class Sentence(val words: List<String>)

operator fun Sentence.iterator(): Iterator<String> = words.iterator()
// or
operator fun Sentence.iterator(): Iterator<String> = object : Iterator<String> {
    val iterator = words.iterator()
    
    override fun hasNext() = iterator.hasNext()

    override fun next() = iterator.next()
}

7.观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。Kotlin中使用 observable properties可以很简便的实现

interface TextChangedListener {
    fun onTextChanged(newText: String)
}

class TextView {
    var listener: TextChangedListener? = null

    var text: String by Delegates.observable("") { prop, old, new ->
        listener?.onTextChanged(new)
    }
}

8.策略模式

定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换，kotlin可以使用高阶函数来实现

class Customer(val name: String, val fee: Double, val discount: (Double) -> Double) {
    fun pricePerMonth() = discount(fee)
}

val studentDiscount = { fee: Double -> fee/2 }
val noDiscount = { fee: Double -> fee }

val student = Customer("Ned", 10.0, studentDiscount)
val regular = Customer("John", 10.0, noDiscount)

参考资料

https://www.runoob.com/design-pattern/strategy-pattern.html
https://www.runoob.com/kotlin/kotlin-tutorial.html