Kotlin学习笔记之泛型和委托

1.1 泛型的基本用法

泛型主要有两种定义方式：一种是定义泛型类，另一种是定义泛型方法，使用的语法结构都是。

定义泛型类

class MyClass<T> {
    fun method(param: T): T {
        return param
    }
}

fun main() {
    MyClass<Int>().method(123)
}
1
2
3
4
5
6
7
8
9

定义泛型方法

class MyClass {
    fun <T> method(param: T): T {
        return param
    }
}

fun main() {
    MyClass().method<Int>(123)
}
1
2
3
4
5
6
7
8
9

对泛型的类型进行限制

可以通过指定上界的方式来对泛型的类型进行约束，比
如这里将method()方法的泛型上界设置为Number类型

在默认情况下，所有的泛型都是可以指定成可空类型的，这是因为在不手动指定上界的时候，泛型的上界默认是Any?。而如果想要让泛型的类型不可为空，只需要将泛型的上界手动指定成Any就可以了。

class MyClass<T : Number> {
    fun method(param: T): T {
        return param
    }
}

fun main() {
    MyClass<Int>().method(123)
}
1
2
3
4
5
6
7
8
9

使用泛型

fun StringBuilder.build(block: StringBuilder.() -> Unit): StringBuilder {
    block()
    return this
}
1
2
3
4

这个函数的作用和apply函数基本是一样的，只是build函数只能作用在StringBuilder类上面，而apply函数是可以作用在所有类上面的。

fun <T> T.build(block: T.() -> Unit): T {
    block()
    return this
}
1
2
3
4

！现在你完全可以像使用apply函数一样去使用build函数了

1.2 类委托和委托属性

委托是一种设计模式，它的基本理念是：操作对象自己不会去处理某段逻辑，而是会把工作委托给另外一个辅助对象去处理。

Java对于委托并没有语言层级的实现;Kotlin中是支持委托功能的，并且将委托功能分为了两种：类委托和委托属性。

类委托

核心思想在于将一个类的具体实现委托给另一个类去完成

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(): Iterator<T> = helperSet.iterator()

}
1
2
3
4
5
6
7
8
9
10
11
12
13

MySet的构造函数中接收了一个HashSet参数，这就相当于一个辅助对象。然后在Set接口所有的方法实现中，我们都没有进行自己的实现，而是调用了辅助对象中相应的方法实现，这其实就是一种委托模式。

如果大部分的方法实现调用辅助对象中的方法，少部分的方法实现由自己来重写，甚至加入一些自己独有的方法，那么MySet就会成为一个全新的数据结构类，这就是委托模式的意义所在。

Kotlin中委托使用的关键字是by，我们只需要在接口声明的后面使用by关键字，再接上受委托的辅助对象，就可以免去之前所写的一大堆模板式的代码了，如下所示：

class MHashSet<T>(val helperSet: HashSet<T>) : Set<T> by helperSet {
    fun hellWorld() = println("hello word")
    override fun isEmpty() = false
}
1
2
3
4

委托属性

委托属性的核心思想是将
一个属性（字段）的具体实现委托给另一个类去完成。

class MyClass {
    var p by 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
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

可以看到，这里使用by关键字连接了左边的p属性和右边的Delegate实例，这是什么意思呢？这种写法就代表着将p属性的具体实现委托给了Delegate类去完成。当调用p属性的时候会自动调用Delegate类的getValue()方法，当给p属性赋值的时候会自动调用Delegate类的setValue()方法。

实现一个自己的lazy函数

学习了Kotlin的委托功能之后，我们就可以对by lazy的工作原理进行解密了，它的基本语法结构如下

val p by lazy { ... }
1

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
    }
}

fun <T> later(block: () -> T) = Later(block)

val uriMatcher by later {
    val matcher = UriMatcher(UriMatcher.NO_MATCH)
    matcher
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14