扩展与委托
目录
1.扩展
- 1.1 扩展函数
- 1.2 扩展属性
- 1.3 扩展伴生对象
- 1.4 扩展的作用域
2.委托
- 2.1 类委托
- 2.2 委托属性
- 2.3 标准委托
1.扩展
在Kotlin中，允许对类进行扩展，不需要继承该类或使用像装饰者这样的任何类型的设计模式，通过一种特殊形式的声明，来实现具体实现某一具体功能。扩展函数是静态解析的，并未对原类增添函数或者属性，对类本身没有影响。
1.1扩展函数
声明一个扩展函数，我们需要用一个接收者类型也就是被扩展的类型来作为他的前缀。 下面代码为Kotlin原生集合类 MutableList
fun MutableList.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 实例的函数，返回的实例作为一个委托，第一次调用 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 委托给 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) {
//因为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自身支持并非常好用的，扩展能使代码更灵活，委托能实现代码重用。运用好他们能很好地加快编写代码的速度。
参考文献：
Kotlin语言中文站、《Kotlin程序开发入门精要》
推荐阅读：
从Java到Kotlin（一）为什么使用Kotlin
从Java到Kotlin（二）基本语法
从Java到Kotlin（三）类和接口
从Java到Kotlin（四）对象与泛型
从Java到Kotlin（五）函数与Lambda表达式
从Java到Kotlin（七）反射和注解
从Java到Kotlin（八）Kotlin的其他技术
Kotlin学习资料汇总
更多精彩文章请扫描下方二维码关注微信公众号"AndroidCzh"：这里将长期为您分享原创文章、Android开发经验等！
QQ交流群： 705929135
