泛型和委托
泛型的基本用法
- Kotlin当中的泛型机制和Java当中的泛型机制还是有异同的
- 所谓泛型就是说在一般的编程模式下面,我们需要给一个变量指定一个具体的类型,而泛型允许我们在不指定具体类型的情况下进行编程,这样编写出来的代码将会拥有更好的扩展性.
- 比如List是一个可以存放数据的列表,但是List并灭有限制我们只能存放整形数据或者字符串数据,因为他没有指定一个具体的类型,而是使用泛型来实现,就是因为如此我们才可以使用List, List…
- 泛型主要有两种定义方式,一种定义泛型类,一种是定义泛型方法,使用的语法结构都是,当然括号当中的T并不是固定要求的,事实上你写任何英文字母都可以,但是通常情况下,T是一种约定俗成的泛型写法.
- 如果我们要定义一个泛型类,就可以这样写
class MyClass<T> {
fun method(param: T) : T {
return param
}
}
- 此时MyClass类就是一个泛型类,MyClass中的方法允许使用T类型的参数和返回值
- 我们在调用MyClass类和method()方法的时候,就可以将泛型指定成具体的类型,如下所示
val myClass = MyClass<Int>()
val res = myClass.method(123)
- 这里我们将MyClass类的泛型定义成为了Int类型,于是method()就可以接收一个Int类型的参数了,并且返回值也变成了Int类型
- 但是如若我们不想定义一个泛型类,只想定义一个泛型方法,可以这样做
- 只需要将定义泛型的语句结构写在方法上面就可以了,如下所示
class MyClass {
fun <T> method(param: T) : T {
return param
}
}
val myClass = MyClass()
val res = myClass.method<Int>(123)
- 可以看到,现在是在调用method()方法的时候指定泛型数据
- 另外Kotlin还拥有非常出色的类型推到机制,例如我们传入了一个Int类型的参数,它能够自动推导出泛型的类型是Int类型,于是我们在调用的时候还可以使用这种简便写法
val myClass = MyClass()
val res = myClass.method(123)
- Kotlin还允许我们对泛型的类型进行限制.比如我们不想将method()方法的泛型指定成任意类型,我们可以通过指定上界的方式来对泛型进行约束,比如在这个地方将method()方法的泛型指定成为Number类型,如下所示
class MyClass {
fun <T: Number> method(param: T) : T {
return param
}
}
- 这种方法就表明,我们只能将nethod()方法的泛型指定成为数字类型,比如:Int, Float,Double等
- 另外在默认的情况下,所有的泛型都是可以指定为可空类型的,这是因为在不手动指定上界的情况下,泛型上街默认是Any?
- 而如果想要泛型的类型不可为空,只需要将泛型的上界手动指定成Any就可以了
- 之前给StringBuilder类编写过一个build函数,代码如下
fun StringBuilder.build(block: StringBuilder.() -> Unit) : StringBuilder {
block()
return this
}
- 这个函数的作用和apply函数基本是一样的,但是build函数只能在StringBuilder类中生效,而apply函数是可以作用在所有类上面的,使用泛型的知识可以对build函数进行扩展,让他实现和apply函数完全一样的功能
- 其实并不复杂,只需要使用将build函数定义成为泛型函数,再将原来所有强制指定StringBuilder的地方替换成为T就可以了
fun <T>.build(block: T.() -> Unit) : T {
block()
return this
}
- 这样编写出来之后,就可以像apply函数一样去使用build函数了
类委托和委托属性
- 委托是一种设计模式,它的基本思想是:操作对象自己不会去处理某段逻辑,而是会把工作委托给另外一个辅助对象去进行处理
- 在Java当中没有对于委托实现语言层面的实现,而在C#等语言当中就对委托进行了原生的支持
- 在Kotlin当中也是支持委托的,并且将委托功能分为了两种:类委托和委托属性
类委托
- 类委托的核心思想是:将一个类的具体实现委托给另外一个类去完成
- 我们曾经使用过Set这种数据类型,他和List比较类似,只是它所存储的数据都是无序的,并且不能重复存放数据
- 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 contanis(elements: Collection<T>) = helperSet.containsAll(elements)
override fun isEmpty() = helperSet.isEmpty()
override fun iterator() = helperSet.iterator()
}
- 可以看到,MySet的构造函数中接受了一个HashSet参数,这就相当于一个辅助对象,然后在Set接口所有的方法实现中,我们都没有进行自己的实现,而是调用了辅助对象的方法进行实现,这个就是一种委托模式.
- 那么这种写法的好处是什么呢?加入我们让大部分的方法实现调用辅助对象当中的方法,少部分的方法实现由自己重写,甚至加入一些自己独有的方法,那么MySet就会成为一个全新的数据结构类,这就是委托模式的意义所在.
- 但是这种写法也有自己的弊端,如果接口中待实现的方法比较少比较好,要是有几十甚至几百个方法的话,每个都去这样调用辅助对象中相应方法实现,呢就要写哭了.
- 在Kotlin当中针对这个问题采用了类委托的方式进行解决.
- Kotlin当中委托使用的关键字是by,我们只需要在接口声明的后面使用by关键字,再接上受委托的辅助对象,就可以免去之前所写的一大堆模板式的代码了,如下所示:
class MySet<T>(val helperSet: HashSet<T>) : Set<T> by helpSet {
}
- 这段代码的作用和上述代码的实现效果是一模一样的,但是借助了类委托之后,代码明显简化了很多
- 另外,如果我们想要对某个方法重新进行实现,只需要单独重写那一个方法就行了,其他的方法仍然可以享受类委托所带来的便利,如下所示
class MySet<T>(val helperSet: HashSet<T>) : Set<T> by helperSet {
fun helloWorld() = println("Hello World")
override fun isEmpty() = false
}
- 在这里我们新增了一个helloWorld()方法,并且重写了isEmpty()方法,让他永远返回false,现在我们的MySet就成为了一个全新的数据结构类
委托属性
- 委托属性的核心思想是将一个属性(字段)的具体实现委托给另外一个类去完成
- 委托属性的语法结构
class MyClass {
var p by Delegate()
}
- 可以看到这里使用了by关键字连接左边的p属性和右边的Delegate实例,这种写法就代表着将p属性的具体实现委托给Delegate类去实现.
- 当调用p属性的时候,会自动调用Delegate类的getValue()方法,当给p属性赋值的时候,会自动调用Delegate类的setValue()方法
- 因此我们还需要对Delegte类进行具体实现才行
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当中的<?>写法,只是为了t通过语法编译而已,至于返回值可以声明成任何类型,根据具体的实现逻辑去写就行
- setValue()方法也是类似的,只不过他要接收三个参数,前两个参数和getValue()方法是相同的,最后一个参数表示具体给委托属性的值,这个参数的类型必须和getValue()方法返回值的类型保持一致.
- 整个委托的工作流程是这样实现的,现在当我们给MyClass的p属性赋值的时候,就会调用Delegate类的setValue()方法,当获取MyClass中的p属性的值的时候,就会调用Delegate类的getValue()方法.
- 还有一种情况可以不用在Delegate类中定义setValue()方法,那就是当我们给MyClass的p属性声明为val关键字的时候,因为p属性使用val关键字进行声明,那么就意味着p属性是无法在初始化之后再进行重新赋值的,因此也没有必要实现setValue()方法,只需要实现getValue()方法就可以了.
实现一个自己的lazy函数
- lazy是kotlin当中的一种懒加载技术.把想要延迟执行的代码放到by lazy代码块当中,这样代码块在一开始就不会执行,只有当变量被首次调用的时候,代码块中的代码才会执行.
- 事实上by laze {…}只有by才是Kotlin当中的关键字,lazy在这里只是一个高阶函数
- 再lazy函数中会创建并且返回一个Delegate对象,当我们调用p属性的时候,其实调用Delegate对象的getValue()方法,然后getValue()方法中又会调用lazy函数传入的Lambda表达式,这样表达式中的代码就得到了执行,并且调用p属性后得到的值就是Lambda表达式中最后一行代码返回的值.
- 新建一个Later.kt文件
import kotlin.reflect.KProperty
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懒加载函数就已经完成了,可以用它来直接代替lazy函数.