在 Kotlin 中, 我们有办法将这种情况告诉编译器. 这种技术称为声明处的类型变异(declaration-sitevariance):我们可以对 Source 的 类型参数 T 添加注解, 来确保 Source 的成员函数只会返回T 类型, 而绝不会消费 T 类型. 为了实现这个目的, 我们可以对 T 添加 out 修饰符:
abstract class Source {
abstract fun nextT(): T
}
fun demo(strs: Source) {
val objects: Source = strs // 这是 OK 的, 因为 T 是一个 out 类型参数
// ...
}
一般规则是: 当 C 类的类型参数 T 声明为 out 时, 那么在 C 的成员函数中, T 类型只允许出现在输出位置, 这样的限制带来的回报就是, C 可以安全地用作 C 的父类型。
除了 out 之外, Kotlin 还提供了另一种类型变异注解: in. 这个注解导致类型参数反向类型变异(contravariant): 这个类型将只能被消费, 而不能被生产. 反向类型变异的一个很好的例子是 Comparable :
abstract class Comparable {
abstract fun compareTo(other: T): Int
}
fun demo(x: Comparable) {
x.compareTo(1.0) // 1.0 类型为 Double, 是 Number 的子类型
// 因此, 我们可以将 x 赋值给 Comparable 类型的变量
val y: Comparable = x // OK!
}
类型投射(Type projection)
class Array(val size: Int) {
fun get(index: Int): T { /* ... */ }
fun set(index: Int, value: T) { /* ... */ }
}
这个类对于类型参数 T 既不能协变, 也不能反向协变. 这就带来很大的不便。
fun copy(from: Array, to: Array) {
assert(from.size == to.size)
for (i in from.indices)
to[i] = from[i]
}
val ints: Array = arrayOf(1, 2, 3)
val any = Array(3)
copy(ints, any) // 错误: 期待的参数类型是 (Array, Array)
我们需要确保的就是 copy() 函数不会做这类不安全的操作. 我们希望禁止这个函数向 from 数组 写入 数据, 我们可以这样声明:
fun copy(from: Array, to: Array) {
// ...
}
这种声明在 Kotlin 中称为 类型投射(type projection): 我们声明的含义是, from 不是一个单纯的数组, 而是 一个被限制(投射)的数组: 我们只能对这个数组调用那些返回值为类型参数 T 的方法。
inline fun runtimeType(): Unit {
println("My type parameter is " + T::class.qualifiedName)
}
inline fun List.collect(): List {
return this.filter { it is T }.map { it as T }
}