泛型
即 “参数化类型
”,将类型参数化,可以用在类
,接口
,函数
上。与 Java
一样,Kotlin
也提供泛型
,为类型安全提供保证,消除类型强转的烦恼。
interface List<T> {
fun get(index: Int): T
}
泛型参数可在类中当普通类型使用。
fun <T> lastElement(list: List<T>): T { ... }
在 fun 关键字后声明 泛型形参,可在参数和返回值处声明使用。高阶函数的例子:
fun <T> List<T>.filter(pridicate: (T) -> Boolean): List<T> { ... }
val <T> List<T>.last: T
get() {
return last()
}
不管是泛型类
、泛型函数
还是泛型属性
,在使用之前必然已经确定了类型。如泛型类在实例化时需要指定泛型类型,泛型函数在调用时必然已推导出泛型类型,并替换为确定的类型实参,泛型属性同理。
泛型(类型参数)是有边界的,可以给泛型设置边界:
interface NumberList<T: Number> {
fun get(index: Int): T
}
不指定边界,则默认上边界为 Any?
。如果希望非空,需要显示指定为
。
和 Java
一样,Kotlin
中的类型参数也会在运行时被擦除,就是说泛型实例的类型实参在运行时是不保留的。不过 Kotlin
可以通过类型参数实化的方式保留类型信息,需要使用内联函数。
由于泛型擦除,下面的普通方法是无法编译的:
fun <T> isA(obj: Any): Boolean {
return obj is T
}
通过内联,下面代码可以通过编译:
inline fun <reified T> isA(obj: Any): Boolean {
return obj is T
}
注意带 reified
类型参数的内联函数不能在 Java
代码中使用,普通内联函数在 Java
中可以像常规函数一样调用,而 reified
的类型参数需要额外处理将类型实参替换到字节码,是永远需要内联的。
实化类型参数也是有限制的,具体可以做:
- 类型转换和检查: 如 is 、as
- 使用反射: T::class
- 获取 java class: T::class.java
- 作为调用其他函数类型的实参。
变型
描述的是具有相同基础类型
和不同类型
参数的泛型类型
之间的关系。这种关系可以是 协变的
或 逆变的
。
先说说不变型
,一个泛型类如 MutableList
,对任意两种类型实参 A
、B
,MutableList
既不是 MutableList
的子类型也不是它的超类型,则称 该类在该类型参数上是不变型的。Java
中的泛型类对所有类型参数都是不变型的。比如 Java
中你不能把一个 List
实例传给形参是 List
的函数,即使 Integer
是 Number
的子类。
前面说的子父类型关系类似于类的子父类关系,比如 A
是 B
的子类,那么 A
是 B
的子类型,任一非空类型是其可空类型的子类型,比如 Person
是 Person?
的子类型,下面会说到 Kotlin
中借助协变使得 List
能够成为 List
的子类型,注意区分 子类
和 子类型
。
Kotlin
中,比如上面自定义的 List
接口,也是不变型的,List
并不是 List
的子类型,因此你不能把一个 List
实例传给形参是 List
的函数。
注意 Kotlin
标准库中的 List
接口是可以的,因为是协变的,别和这里自定义的 List
搞混了
对于 out 泛型
,我们能够将使用子类泛型的对象赋值给使用父类泛型的对象。如果将上面的 List
接口定义改为:
interface List<out T> {
fun get(index: Int): T
}
则称该 List
接口是协变的,如果基础类型间有子类型关系,则泛型类也具有相同的子类型关系。如 Int
是 Number
的子类型,则 上面定义的 List
也是List
的子类型。这样就可以将 一个 List
实例传给形参是 List
的函数了,简单来说协变——父类引用指向子类
当然,out
也不可以滥用 ,因为不安全,比如将一个 List
实例传入形参是 List
的函数,该函数像实例中添加 Any
类型的数据显然是错误的:
fun addMore(list: List<Any>) {
list.add("abc")
}
addMore(listOf(1, 2, 3))
为了防止这种风险,如果类在该类型参数上是协变
的,那么该类型参数只能出现在返回值位置,我们称之为 out
位置,即该泛型参数只读
,编译器也会做这种检查。Kotlin
中的 List
接口就是协变
的。集合可读、不可写,集合泛型协变。
和协变相反,对于 in 泛型
,我们可以将使用父类泛型的对象赋值给使用子类泛型的对象。如果一个泛型类 MyClass
是逆变的,则对于 有子类型关系的 A
和 B
(A是B的子类型),则 MyClass
是 MyClass
的超类型。逆变——子类引用指向父类
例如 Comparable 接口:
public interface Comparable<in T> {
public operator fun compareTo(other: T): Int
}
那么,Comparable
是 Comparable
的子类型。可以尝试理解成“能对 Any
类型进行比较”的比较器也能比较 Int
类型“。
类似的,这里的泛型参数只能出现在函数参数位置,我们称之为 in
位置。集合可读 Any 、可写,集合泛型逆变。
即声明泛型的地方产生变型
。前面说的变型是针对类的所有实例的。而声明点变型则可以只针对某一实例变型。如:
val list: MutableList<out Int> = MutableList()
list.add(1,2) //报错
上面代码会将 list
变为只读的。
在 Java
中,没有类的变型声明,只通过声明点产生型变,如:
public interface Stream<T> {
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
}
与 Kotlin
不同的是,Java
通过 ? super T
产生逆变
,? extends R
产生协变
。
List<*>
对应与 Java
中的 List>
, 表示不确定的任意类型类型实参。可能是 Int
,可能是Any
,是确定的某种类型,但对使用者是未知的,因而不能生产该值,只能访问,当作 Any?
访问。注意和 List
作区分。
Kotlin
的泛型概念和声明和 Java
相当接近。Kotlin
的类型实参和 Java
一样会在运行期擦除。Kotlin
可以通过类型参数实化保留运行时类型实参,需要借助内联函数。变型
指的是具有相同基础类型和不同类型参数的泛型类型间的子类型关系。他指出了如果一个泛型类型的类型参数是另一个泛型类型类型参数的子类型,那么这个泛型类就是另一个泛型类的子类型或超类型。协变
的,那么该类型参数只能出现在 out
位置上。逆变
相反。Java
的泛型类都是不变型的。Java
的变型都是该方式。Kotlin
既可以使用声明点变型,也可以在整个泛型类上声明变型。星号投影
。