本文介绍 Kotlin 中的泛型,可与 Java 基础:泛型 配合食用。
文章目录
一、为什么要有泛型
- 效率、成本
- 减少样板代码的编写
二、泛型的分类
- 泛型类
- 泛型方法
三、泛型的关键字
3.1 T
T 代表任意一个类型,可以为任意字符串,一般为:T、U、S、E、K、V。
- T、U、S:任意类型
- E:集合的元素类型
- K、V:Map 的 key 和 value 类型
3.2 out
通配符,相当于 Java 的 ? extend
3.3 in
通配符,相当于 Java 的 ? super
四、泛型类、方法的定义
4.1 泛型类的定义
class AClass<T> ...
class AClass<out T> ...
class AClass<in T> ...
<T> 在类名后声明。在该类中,可以
- 使用 T 作为对象的类型声明
val a: T;
- 使用 T 作为泛型类型对象的类型参数
List<T> list;
- 使用 T 作为方法返回类型前的声明(所以泛型类中的泛型方法可以省去返回类型前的 )
见泛型方法的定义
4.2 泛型方法的定义
fun <T> ...
<T> 在方法返回类型前声明。在该方法中,可以
- 使用 T 作为方法的返回类型
fun <T> foo() : T …
- 使用 T 作为方法的参数类型
fun <T> foo(t: T) …
- 使用 T 作为方法的泛型参数的类型参数
fun <T> foo(list: List<T>) …
五、泛型类、方法的使用
使用即泛型类的实例化。
5.1 泛型实现类
指类型参数指定为一个确定的单一类,如 String 对应 AClass<String>,它表示:
一个泛型实现类,类型参数是 String(即 AClass<T>,使用时 T 已经被指定为 String)。
5.2 通配类
5.2.1 AClass< out BClass >
它代表一批泛型实现类,这批实现类的特点是:
- 它们的类型参数只能是 BClass 的子类。
- 它们自己,都是 AClass<out BClass> 的子类。
这种泛型实现类
与通配类
的父子关系,和泛型实现类的类型参数
与通配类的类型参数
的父子关系相同的关系,称为协变
。
当实现类转为 AClass<out BClass> 时:
- 可以 get 到 BClass,因为所有实现类的类型参数的共同上界就是 BClass。
- 不能 set 任何值,因为不确定实现类的类型参数是哪个 BClass 的子类。
5.2.2 AClass< in BClass >
它代表一批泛型实现类,这批实现类的特点是:
- 它们的类型参数只能是 BClass 的父类。
- 它们自己,都是 AClass 的子类。
这种泛型实现类
与通配类
的父子关系,和泛型实现类的类型参数
与通配类的类型参数
的父子关系相反的关系,称为逆变
。
当实现类转为 AClass 时:
- 不能 get 到 BClass,只能 get 到 Object,因为所有实现类的类型参数的共同上界只有 Object。
- 可以 set BClass 及其子类,因为一定是覆盖真正的实现类的类型参数的。
5.2.3 类定义中的 out、in
Kotlin 中为了方便开发,out、in 除了可以在使用时出现,也可以放在定义时,如 class AClass<out T>。
class AClass<T>
的定义 + AClass<out BClass>
的使用相当于
class AClass<out T>
的定义 + AClass<BClass>
的使用。
由于 out、in 的协变、逆变特性,出现在定义里时,Kotlin 会对类做一些限制:
- out 的泛型类不允许 T 作为方法的参数,除非加上 @UnsafeVariance 的注解。(只能 get,不能 set)
- in 的泛型类不允许 T 作为返回类型。(只能 set,不能 get)
六、代码示例
6.1 out、in 在使用中时
class ChangeKotlin {
open class A
open class B : A()
open class C : B()
class AClass<T> {
private var mT: T? = null
fun get(): T? {
return mT
}
fun set(t: T) {
mT = t
}
}
fun <T> d(list: List<T>) {
}
fun main() {
val aClass: AClass<String> = AClass()
var aClass1: AClass<Any> = AClass()
aClass1 = aClass // 报错
val aClassA: AClass<A> = AClass()
val aClassB: AClass<B> = AClass()
val aClassC: AClass<C> = AClass()
val aClassExtendB1: AClass<out B> = aClassA // 报错
val aClassExtendB2: AClass<out B> = aClassB
val aClassExtendB3: AClass<out B> = aClassC
val b2: B? = aClassExtendB2.get() // 可以 get 到 B
aClassExtendB2.set() // 报错,set 任何值都会报错
val aClassSuperB1: AClass<in B> = aClassA
val aClassSuperB2: AClass<in B> = aClassB
val aClassSuperB3: AClass<in B> = aClassC // 报错
val o: Any? = aClassSuperB1.get() // 只能 get 到 Any
aClassSuperB1.set(A()) // 报错,set 除 B 及其子类以外的类型就会报错
aClassSuperB1.set(B())
aClassSuperB1.set(C())
}
}
6.2 out、in 在定义中时
class ChangeKotlin2 {
open class A
open class B : A()
open class C : B()
class AClassOut<out T> {
private var mT: T? = null
fun get(): T? {
return mT
}
// 报错,T 不允许作为参数,除非加上 @UnsafeVariance 的注解
//fun set(t: T) {
// mT = t
//}
}
class AClassIn<in T> {
private var mT: T? = null
// 返回类型写 T? 会报错,不允许 T 作为返回类型
fun get(): Any? {
return mT
}
fun set(t: T) {
mT = t
}
}
fun main() {
val aClass: AClassOut<String> = AClassOut()
var aClass1: AClassOut<Any> = AClassOut()
aClass1 = aClass // 正常
val aClassAOut: AClassOut<A> = AClassOut()
val aClassBOut: AClassOut<B> = AClassOut()
val aClassCOut: AClassOut<C> = AClassOut()
val aClassExtendB1: AClassOut<B> = aClassAOut // 报错
val aClassExtendB2: AClassOut<B> = aClassBOut
val aClassExtendB3: AClassOut<B> = aClassCOut
val b2: B? = aClassExtendB2.get() // 可以 get 到 B
aClassExtendB3.set(B()) // 报错,在定义期间就限制了没有这样的方法
val aClassAIn: AClassIn<A> = AClassIn()
val aClassBIn: AClassIn<B> = AClassIn()
val aClassCIn: AClassIn<C> = AClassIn()
val aClassSuperB1: AClassIn<B> = aClassAIn
val aClassSuperB2: AClassIn<B> = aClassBIn
val aClassSuperB3: AClassIn<B> = aClassCIn // 报错
val o: Any? = aClassSuperB1.get() // 只能 get 到 Any
aClassSuperB1.set(A()) // 报错,set 除 B 及其子类以外的类型就会报错
aClassSuperB1.set(B())
aClassSuperB1.set(C())
}
}