学习Kotlin(六)扩展与委托

1.扩展

1.1 扩展函数
1.2 扩展属性
1.3 扩展伴生对象
1.4 扩展的作用域

2.委托

2.1 类委托
2.2 委托属性
2.3 标准委托

1.扩展

在Kotlin中，允许对类进行扩展，不需要继承该类或使用像装饰者这样的任何类型的设计模式，通过一种特殊形式的声明，来实现具体实现某一具体功能。扩展函数是静态解析的，并未对原类增添函数或者属性，对类本身没有影响。

1.1扩展函数

声明一个扩展函数，我们需要用一个接收者类型也就是被扩展的类型来作为他的前缀。下面代码为Kotlin原生集合类 MutableList 添加一个 swap 函数：

fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1] // “this”对应该列表
    this[index1] = this[index2]
    this[index2] = tmp
}

上面代码用MutableList作为接受者类型，对其进行扩展，为其添加一个 swap 函数，当我们调用 swap 函数时，可以这样：

val mutableList = mutableListOf(1, 2, 3)
mutableList.swap(1, 2) //调用扩展函数swap()
println(mutableList)

运行代码，得到结果

内部成员函数名与扩展函数名相同
如果扩展函数与内部成员函数冲突，如下所示：

class User {
    fun print() {
        println("内部成员函数")
    }
}

//扩展函数
fun User.print() {
    println("扩展函数")
}

//调用
User().print()

运行代码，得到结果：

由上面例子可得，如果扩展函数的函数名跟内部成员函数的函数名冲突，会优先调用内部成员函数。

可空接收者
可以为可空的接收者类型定义扩展，如下所示：

//扩展函数
fun Any?.toString(): String {
    if (this == null) return "null"
    return toString()
}

//调用
var a = null
a.toString()
println(a)
var b = "not null"
b.toString()
println(b)

运行代码，得到结果：

上面代码中，我们对可空的接受者定义扩展，检测调用者是否为null，如果为null，返回"null"，如果不为null，返回Any.toString()

1.2扩展属性

扩展属性是对属性的扩展，如下所示：

class User {
    //必须声明为public（Kotlin默认是public）
    //否则扩展属性无法访问该变量
    var mValue = 0
}

//扩展属性
var User.value: Int
    get() = mValue
    set(value) {
        mValue = value
    }

//调用扩展函数
var user = User()
user.value = 2
println(user.value)

运行代码，得到结果：

上面代码中对 mValue 进行了属性扩展，抵用了扩展属性实现了 setter 方法，对 mValue 进行赋值，再通过扩展属性实现了 getter 方法，获取到 mValue 的值。

1.3扩展伴生对象

除了扩展函数和扩展属性外，还可以对伴生对象进行扩展，代码如下：

class User {
    companion object {
    }
}

//扩展伴生对象
fun User.Companion.foo() {
    println("伴生对象扩展")
}

//调用
User.foo()

运行代码，得到结果

1.4扩展的作用域

在不同包里进行扩展
上面的代码都是在同一个包里进行扩展，如果在不同包里要进行扩展，就要用import来导入资源了，如下所示：

package com.demo.czh.otherpackage

class OtherUser {

}

fun OtherUser.print() {
    println("其他包的")
}

在其他包中调用

package com.demo.czh.activitydemo

import com.demo.czh.otherpackage.OtherUser
import com.demo.czh.otherpackage.print

User().print()
OtherUser().print()

运行代码，得到结果：

由上面例子可得，如果要在不用的包里进行扩展，要在调用处 import 扩展的资源。

扩展声明为成员
在一个类内部你可以为另一个类声明扩展，如下所示：

//定义User类，添加一个printUser()函数
class User {
    fun printUser(){
        println("User")
    }
}

//定义User2类，在里面对User类进行扩展
class User2 {
    fun printUser2() {
        println("User2")
    }

    //扩展函数
    fun User.print() {
        printUser()
        printUser2()
    }

    fun getUser(user: User) {
        //调用扩展函数
        user.print()
    }
}

//调用
User2().getUser(User())

运行代码，得到结果：

扩展声明所在的类的实例称为分发接收者，扩展方法调用所在的接收者类型的实例称为扩展接收者。对于分发接收者和扩展接收者的成员名字冲突的情况，扩展接收者优先。如果要引用分发接收者的成员，可以这样写：

//User类不变
class User {
    fun printUser(){
        println("User")
    }
}

//User2
class User2 {
    fun printUser() {
        println("User2")
    }

    fun User.print() {
        printUser()
        //表示调用User2的printUser()函数
        [email protected]()
    }

    fun getUser(user: User) {
        //调用扩展方法
        user.print()
    }
}

运行代码，得到结果：

上面 User.print() 这个扩展函数中，用到了限定的 this 语法来调用 User2 的printUser() 函数。

扩展成员的继承
声明为成员的扩展可以声明为 open 并在子类中覆盖。这意味着这些函数的分发对于分发接收者类型是虚拟的，但对于扩展接收者类型是静态的。

open class D {
}

class D1 : D() {
}

open class C {
    open fun D.foo() {
        println("D.foo in C")
    }

    open fun D1.foo() {
        println("D1.foo in C")
    }

    fun caller(d: D) {
        d.foo()   // 调用扩展函数
    }

    fun caller2(d1: D1) {
        d1.foo()   // 调用扩展函数
    }
}

class C1 : C() {
    override fun D.foo() {
        println("D.foo in C1")
    }

    override fun D1.foo() {
        println("D1.foo in C1")
    }
}

//调用
C().caller(D())   
C1().caller(D()) 
C().caller(D1()) 
C().caller2(D1())
C1().caller2(D1())

运行代码，得到结果：

2.委托

在Kotlin中，如果有多个地方用到了相同的代码，可以用委托来处理。

2.1类委托

委托模式是实现继承一个很好的的替代方式，Kotlin支持委托模式，不用为了实现委托模式而编写样板代码。举个例子：

//定义一个接口 Base
interface Base {
    fun print()
}

//定义一个 ImplBase 实现接口 Base 
class ImplBase(val i: Int) : Base {
    override fun print() {
        println(i)
    }
}

//定义一个 Drived 类实现接口 Base 
class Drived(b: Base) : Base {
    //这里需要 override 接口 Base 里的方法
    override fun print() {
    }
}

//如果使用委托模式的话，可以把 Base 里的方法委托给 Drived
class Drived(b: Base) : Base by b

//调用 print() 方法
var b = ImplBase(10)
Drived(b).print()

//运行代码，打印结果为 10

从上面代码可以看出，Derived 类通过使用 by 关键字将 Base 接口的 print 方法委托给对象 b ，如果不进行委托的话，则要 override Base 接口的 print 方法。如果出现委托后仍然 override 的情况，编译器会使用你的 override 实现取代委托对象中的实现，如下所示：

//委托后仍然 override 
class Drived(b: Base) : Base by b {
    override fun print() {
        println("abc")
    }
}

//调用 print() 方法
var b = ImplBase(10)
Drived(b).print()

//运行代码，打印结果为 abc

2.2 委托属性

在实际应用中，有很多类的属性都拥有 getter 和 setter 函数，这些函数大部分都是相同的。Kotlin允许委托属性，把所有相同的 getter 和 setter 函数放到同一个委托类中，这样能大大减少冗余代码。举个例子：

class User1 {
    var userName: String = ""
        get() = field
        set(value) {
            field = value
        }
}
class User2 {
    var userName: String = ""
        get() = field
        set(value) {
            field = value
        }
}

User1和User2都有相同的 getter 和 setter 函数，把它们放到委托类中，如下：

//定义一个委托类Delegate 
class Delegate {
    var userName = ""

    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        println("getValue  类名：$thisRef, 属性名：${property.name}")
        return userName
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("setValue  类名：$thisRef, 属性名：${property.name}，值：$value")
        userName = value
    }
}

//将 userName 委托给 Delegate
class User1 {
    var userName: String by Delegate()
}
class User2 {
    var userName: String by Delegate()
}

//调用 getter 和 setter 函数
var user1 = User1()
user1.userName = "user1"
println(user1.userName)
var user2 = User2()
user2.userName = "user2"
println(user2.userName)

运行代码，得到结果：

可以看到，User1 和 User2 都将 userName 委托给 Delegate ，在 Delegate 内完成 getter/setter 函数，去除了相同的代码。

2.3 标准委托

Kotlin标准库中提供了一些有用的委托函数：

延迟委托
可观察属性委托
Map委托

延迟委托

lazy()是接受一个 lambda 表达式作为参数，并返回一个 Lazy <T> 实例的函数，返回的实例作为一个委托，第一次调用 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果，之后再调用 get() 返回记录的结果。

val lazyValue: String by lazy {
    println("computed!")
    "Hello"
}

//调用两次
println(lazyValue)
println(lazyValue)

运行代码，得到结果：

默认情况下，对于 lazy 属性的求值是同步锁的（synchronized）：该值只在一个线程中计算，并且所有线程会看到相同的值。如果初始化委托的同步锁不是必需的，这样多个线程可以同时执行，那么将 LazyThreadSafetyMode.PUBLICATION 作为参数传递给 lazy() 函数。如下所示：

val lazyValue: String by lazy(LazyThreadSafetyMode.PUBLICATION ) {
    "Hello"
}

而如果你确定初始化将总是发生在单个线程，那么你可以使用 LazyThreadSafetyMode.NONE 模式，它不会有任何线程安全的保证和相关的开销，如下所示：

val lazyValue: String by lazy(LazyThreadSafetyMode.NONE) {
    "Hello"
}

可观察属性委托

实现可观察属性委托的函数是Delegates.observable()，当我们使用该委托函数时，可以观察属性的变化，如下所示：

var name: String by Delegates.observable("Czh") { property, oldValue, newValue ->
    println("属性名：$property  旧值：$oldValue  新值：$newValue")
}

//修改name的值
name = "abc"
name = "hello"

运行代码，得到结果：

Delegates.observable()接收两个参数，第一个是初始值，第二个是修改时处理程序（handler）。每当我们给属性赋值时会调用该处理程序，他有三个参数，第一个是被赋值的属性，第二个是旧值，第三个是新值。如果想拦截属性的赋值操作，并且否决他的赋值操作，可以用vetoable()取代 observable()，传递给vetoable()的修改时处理程序会返回一个boolean类型，如果返回true，允许赋值，返回false则反之。如下所示：

var name: String by Delegates.vetoable("Czh") { property, oldValue, newValue ->
    if (newValue.equals("abc")) {
        println("属性名：$property  旧值：$oldValue  新值：$newValue")
        true
    } else {
        println("不能修改为除了abc以外的值")
        false
    }
}

//修改name的值
name = "abc"
name = "hello"

运行代码，得到结果：

Map委托

Map委托是指用Map实例自身作为委托来实现委托属性，通常用于解析 JSON ，如下所示：

//新建User类，主构函数要求传入一个Map
class User(val map: Map<String, Any>) {
    //声明一个 String 委托给 map
    val name: String by map
    //因为 Map 为只读，所以只能用 val 声明
    val age: Int     by map
}

var map = mapOf("name" to "Czh", "age" to 22)
var user = User(map)
println("${user.name}  ${user.age}")  
//打印结果为  Czh  22

因为Map只有getValue方法而没有setValue方法，所以不能通过User对象设置值，这时可以把User的主构函数改为传入一个MutableMap，并把属性委托给MutableMap，如下所示：

class User(val map: MutableMap<String, Any>) {
    //因为MutableMap为读写，可以用var声明
    var name: String by map
    var age: Int     by map
}

var map = mutableMapOf("name" to "Czh", "age" to 22)
var user = User(map)
user.name = "James Harden"
user.age = 28
println("${user.name}  ${user.age}")
//打印结果为  James Harden  28

总结

本篇文章简述了Kotlin中扩展和委托的使用方法。扩展和委托都是Kotlin自身支持并非常好用的，扩展能使代码更灵活，委托能实现代码重用。运用好他们能很好地加快编写代码的速度。

原文链接：https://juejin.im/post/5a9648466fb9a0633b213d73