Kotlin
中新引入的语法——委托。委托是一种设计模式,它的基本理念是:操作对象自己不会去处理某段逻辑,而是会把工作委托给另外一个辅助对象去处理。 比如调用A
类的methodA
方法,其实背后是B
类的methodB
去执行。
Kotlin
将委托功能分为了两种:类委托和委托属性。
类委托的核心思想在于将一个类的具体实现委托给另一个类去完成。 比如Set
,它所存储的数据是无序的,并且不能存储重复的数据。Set
是一个接口,如果要使用它的话,需要使用它具体的实现类,比如HashSet
。而借助于委托模式,可以轻松实现一个自己的实现类。比如这里定义 一个MySet
,并让它实现Set
接口,代码如下所示:
class MySet<T>(val helperSet: HashSet<T>) : Set<T> {
override val size: Int
get() = helperSet.size
override fun contains(element: T) = helperSet.contains(element)
override fun containsAll(elements: Collection<T>) = helperSet.containsAll(elements)
override fun isEmpty() = helperSet.isEmpty()
override fun iterator() = helperSet.iterator()
}
可以看到,MySet
的构造函数中接收了一个HashSet
参数,这就相当于一个辅助对象。然后在Set
接口所有的方法实现中,都没有进行自己的实现,而是调用了辅助对象中相应的方法实现,这其实就是一种委托模式。
那么,既然都是调用辅助对象的方法实现,那还不如直接使用辅助对象。这么说确实没错,但如果我们只是让大部分的方法实现调用辅助对象中的方法,少部分的方法实现由自己来重写,甚至加入一些自己独有的方法,那么MySet
就会成为一个全新的数据结构类,这就是委托模式的意义所在。
但是这种写法也有一定的弊端,如果接口中的待实现方法比较少还好,要是有几十甚至上百个方法的话,每个都去这样调用辅助对象中的相应方法实现,那可真是要写哭了。那么这个问题 有没有什么解决方案呢?在Java
中确实没有,但是在Kotlin
中可以通过类委托的功能来解决。
Kotlin
中委托使用的关键字是by
,只需要在接口声明的后面使用by
关键字,再接上受委托的辅助对象,就可以免去之前所写的一大堆模板式的代码了, 如下所示:
class MySet<T>(val helperSet: HashSet<T>) : Set<T> by heplerSet {
}
这两段代码实现的效果是一模一样的,但是借助了类委托的功能之后,代码明显简化了太多。另外,如果我们要对某个方法进行重新实现,只需要单独重写那一个方法就可以了,其他的方法仍然可以享受类委托所带来的便利,如下所示:
class MySet<T>(val helperSet: HashSet<T>) : Set<T> by helperSet {
fun helloWorld() = println("Hello World")
override fun isEmpty() = false
}
这里新增了一个helloWorld()
方法,并且重写了isEmpty()
方法,让它永远返回false
。这当然是一种错误的做法,这里仅仅是为了演示一下而已。现在MySet
就成为了一个全新的数据结构类,它不仅永远不会为空,而且还能打印helloWorld()
,至于其它Set
接口中的功能,则和HashSet
保持一致。这就是Kotlin
的类委托所能实现的功能。
类委托的核心思想是将一个类的具体实现委托给另一个类去完成,而委托属性的核心思想是将一个属性(字段)的具体实现委托给另一个类去完成。 委托属性的语法结构,如下所示:
class MyClass {
var p by Delegate()
}
可以看到,这里使用by
关键字连接了左边的p
属性和右边的Delegate
实例,这种写法就代表着将p
属性的具体实现委托给了Delegate
类去完成。当调用p
属性的时候会自动调用Delegate
类的getValue()
方法,当给p
属性赋值的时候会自动调用Delegate
类的setValue()
方法。
因此,还得对Delegate
类进行具体的实现才行,代码如下所示:
class Delegate {
var propValue: Any? = null
operator fun getValue(myClass: MyClass, prop: KProperty<*>): Any? {
return propValue
}
operator fun setValue(myClass: MyClass, prop: KProperty<*>, value: Any?) {
propValue = value
}
}
这是一种标准的代码实现模板,在Delegate
类中我们必须实现getValue()
和setValue()
这 两个方法,并且都要使用operator
关键字进行声明。
getValue()
方法要接收两个参数:第一个参数用于声明该Delegate
类的委托功能可以在什么类中使用,这里写成MyClass
表示仅可在MyClass
类中使用;第二个参数KProperty<*>
是 Kotlin
中的一个属性操作类,可用于获取各种属性相关的值,在当前场景下用不着,但是必须在方法参数上进行声明。另外,<*>
这种泛型的写法表示你不知道或者不关心泛型的具体类型,只是为了通过语法编译而已,有点类似于Java
中<?>
的写法。至于返回值可以声明成任何类型,根据具体的实现逻辑去写就行了,上述代码只是一种示例写法。
setValue()
方法也是相似的,只不过它要接收3
个参数。前两个参数和getValue()
方法是相 同的,最后一个参数表示具体要赋值给委托属性的值,这个参数的类型必须和getValue()
方法返回值的类型保持一致。
整个委托属性的工作流程就是这样实现的,现在当我们给MyClass
的p
属性赋值时,就会调用Delegate
类的setValue()
方法,当获取MyClass
中p
属性的值时,就会调用Delegate
类的getValue()
方法。
不过,其实还存在一种情况可以不用在Delegate
类中实现setValue()
方法,那就是MyClass
中的p
属性是使用val
关键字声明的。这一点也很好理解,如果p
属性是使用val
关键字声明的,那么就意味着p
属性是无法在初始化之后被重新赋值的,因此也就没有必要实现 setValue()
方法,只需要实现getValue()
方法就可以了。
Kotlin
通过by
关键字就可以实现委托的效果,比如的by lazy { }
,其实就是利用委托实现的延迟初始化语法。 以下是它的使用:
val laziness: String by lazy {
// by lazy实现延迟初化效果
println("I will hava a value")
"I am a lazy-initialized string"
}
这里使用了一种懒加载技术,把想要延迟执行的代码放到by lazy
代码块中,这样代码块中的代码在一开始的时候就不会执行,只有当laziness
变量首次被调用的时候,代码块中的代码才会执行。
学习了Kotlin
的委托功能之后,就可以对by lazy
的工作原理进行解密了,它的基本语法结构如下:
val p by lazy {
... }
by lazy
并不是连在一起的关键字,只有by
才是Kotlin
中的关键字,lazy
在这里只是一个高阶函数而已。 在lazy
函数中会创建并返回一个Delegate
对象,当我们调用p
属性的时候,其实调用的是Delegate
对象的getValue()
方法,然后getValue(
)方法中又会调用lazy
函数传入的Lambda
表达式,这样表达式中的代码就可以得到执行了,并且调用p
属性后得到的值就是Lambda
表达式中最后一行代码的返回值。
这样看来,Kotlin
的懒加载技术也并没有那么神秘,掌握了它的实现原理之后,我们也可以实现 一个自己的lazy
函数。新建一个Later.kt
文件,并编写如下代码:
class Later<T>(val block: () -> T) {
}
首先定义了一个Later
类,并将它指定成泛型类。Later
的构造函数中接收一个函数类型参数,这个函数类型参数不接收任何参数,并且返回值类型就是Later
类指定的泛型。
接着在Later
类中实现getValue()
方法,代码如下所示:
class Later<T>(val block: () -> T) {
var value: Any? = null
operator fun getValue(any: Any?, prop: KProperty<*>): T {
if (value == null) {
value = block()
}
return value as T
}
}
这里将getValue()
方法的第一个参数指定成了Any?
类型,表示希望Later
的委托功能在所有类中都可以使用。然后使用了一个value
变量对值进行缓存,如果value
为空就调用构造函数中传入的函数类型参数去获取值,否则就直接返回。由于懒加载技术是不会对属性进行赋值的,因此这里就不用实现setValue()
方法了。
代码写到这里,委托属性的功能就已经完成了。虽然我们可以立刻使用它,不过为了让它的用法更加类似于lazy
函数,最好再定义一个顶层函数。这个函数直接写在Later.kt
文件中就可以了,但是要定义在Later
类的外面,因为只有不定义在任何类当中的函数才是顶层函数。代码 如下所示:
fun <T> later(block: () -> T) = Later(block)
我们将这个顶层函数也定义成了泛型函数,并且它也接收一个函数类型参数。这个顶层函数的 作用很简单:创建Later
类的实例,并将接收的函数类型参数传给Later
类的构造函数。
现在,我们自己编写的later
懒加载函数就已经完成了,你可以直接使用它来替代之前的lazy
函数,如下所示:
val uriMatcher by later {
val matcher = UriMatcher(UriMatcher.NO_MATCH)
matcher.addURI(authority, "book", bookDir)
matcher.addURI(authority, "book/#", bookItem)
matcher.addURI(authority, "category", categoryDir)
matcher.addURI(authority, "category/#", categoryItem)
matcher
}
但是如何才能验证later
函数的懒加载功能有没有生效呢?这里我有一个非常简单方便的验证 方法,写法如下:
val p by later {
Log.d("TAG", "run codes inside later block")
"test later"
}
可以看到,我们在later
函数的代码块中打印了一行日志。将这段代码放到任何一Activity
中,并在按钮的点击事件里调用p
属性。
你会发现,当Activity
启动的时候,later
函数中的那行日志是不会打印的。只有当你首次点击按钮的时候,日志才会打印出来,说明代码块中的代码成功执行了。而当你再次点击按钮的时候,日志也不会再打印出来,因为代码块中的代码只会执行一次。
通过这种方式就可以验证懒加载功能到底有没有生效了,你可以自己测试一下。
另外,必须说明的是,虽然我们编写了一个自己的懒加载函数,但由于简单起见,这里只是大 致还原了lazy
函数的基本实现原理,在一些诸如同步、空值处理等方面并没有实现得很严谨。 因此,在正式的项目中,使用Kotlin
内置的lazy
函数才是最佳的选择。
通过委托可以代替多继承实现需求:
interface CanFly {
fun fly()
}
interface CanEat {
fun eat()
}
open class Flyer : CanFly {
override fun fly() {
println("I can fly")
}
}
open class Animal : CanEat {
override fun eat() {
println("I can eat")
}
}
class Bird(flyer: Flyer, animal: Animal) : CanFly by flyer, CanEat by animal {
}
fun main() {
val flyer = Flyer()
val animal = Animal()
val b = Bird(flyer, animal)
b.fly()
b.eat()
}
有人可能会有疑问:首先,委托方式怎么跟接口实现多继承如此相似,而且好像也并没有简单多少,其次,这种方式好像跟组合也很像,那么它到底有什么优势呢?主要有以下两点:
- 前面说到接口是无状态的,所以即使它提供了默认方法实现也是很简单的,不能实现复杂的逻辑,也不推荐在接口中实现复杂的方法逻辑。我们可以利用上面委托的这种方式,虽然它也是接口委托,但它是用一个具体的类去实现方法逻辑,可以拥有更强大的能力;
- 假设我们需要继承的类是
A
,委托对象是B
、C
、我们在具体调用的时候并不是像组合一样A.B.method
,而是可以直接调用A.method
,这更能表达A
拥有该method
的能力, 更加直观,虽然背后也是通过委托对象来执行具体的方法逻辑的;