Kotlin基础之泛型

Posted by AlexWan on 2017-07-03

泛型

与Java一样,Koltin的类也有类型参数

class Box<T>(t: T){
var value = t
}

常规来说,创建这样的类,需要提供具体的类型

val box: Box<Int> = Box<Int>(1)

当类型可以从构造参数或其他上下文中推断出时,可以忽略类型参数

val box = Box(1) // 1 has type Int, so the compiler figures out that we are talking about Box<Int>

变型

Java类型系统中最复杂的其中一个部分就是通配符类型(Java泛型FAQ)。而Kotlin没有任何的通配符类型,它使用声明处变型类型投影两种方式替代。

通配符 - 使用问号表示的类型参数,表示未知类型的类型约束方法。

首先,先思考为什么Java需要这些难以理解的通配符。Effective Java解释了这个问题,第28条:使用受限通配符来增加API灵活性。首先,Java中泛型为不可变类型,意味List<String>不是List<Object>的子类型。为什么这样?如果List为可变量,List<>不会比Java的数组更好,并且下面的代码能够成功编译,但在运行时会引起异常。

// Java
List<String> strs = new ArrayList<String>();
List<Object> objs = strs; // 会引起错误,Java禁止这样使用。
objs.add(1); // Here we put an Integer into a list of Strings
String s = strs.get(0); // 类转换异常:无法将Integer转换为String

所以Java禁止这样做,目的是保证运行时安全。但会有一些影响。比如:Collection接口的addAll()方法,这个方法的签名是什么?我们直觉上会这样做:

// Java
interface Collection<E> ... {
void addAll(Collection<E> items);
}

考虑到运行时安全,我们无法做到像下面的简单操作。

// Java
void copyAll(Collection<Object> to, Collection<String> from) {
to.addAll(from); // !!! Would not compile with the naive declaration of addAll:
// Collection<String> is not a subtype of Collection<Object>
}

在Java中学到的教训,就是Effective Java 第25条:Prefer lists to arrays

实际上,addAll()的方法签名是:

// Java
interface Collection<E> ... {
void addAll(Collection<? extends E> items);
}

通配符参数? extends E表明方法接收类型为E的子类集合,而非E本身。意味着可以安全读取集合中为E的值(集合的元素类型为E的子类实例),但无法写入E,因为我们不知道对象是否是E未知的子类。作为交换,我们希望得到这些行为:Collection<String>Collection<? extends Object>子类型,带有extendsupper限制的通配符让类型变为协变

理解这点很简单:如果只从集合中获取item,可使用String的集合来读取Object。相反,如果只向集合放入item,可以向Object集合中放入String类型。Java中使用List<Object>表示List<? super String>的超类。

后一个被称为协变量,只能调用基于List<? super String>,且使用String作为参数的方法(如:可以调用add(String)set(int, String)),而如果你调用List<T>返回的T,只能获取到Object类型,而不是String

Joshua Bloch成只能读取的对象为生产者,只能写入的对象为消费者。他建议:为了最大化灵活性,在表示消费者和生产者的输入参数上使用通配符类型,并提供下面的话来方便记忆:

PECS:表示Producer-Extends, Consumer-Super。

如果使用生产者对象,比如说List<? extends Foo>,不能在这个对象上调用add()set方法,但并不表示这个对象是不变的:如不会禁止调用clear()来清空list,因为clear()没有任何参数。通配符(或其他变型的类型)能够保证类型安全,非可变则是完全不同的说法。

声明点变型

假设现有一个Source<T>泛型接口,没有使用T作为参数的方法,只有一个返回T的方法

// Java
interface Source<T> {
T nextT();
}

那么使用Source<Object>的变型来存储Source<String>实例引用是类型安全的(因为没有消费者方法)。但是Java仍会禁止这样做:

// Java
void demo(Source<String> strs) {
Source<Object> objects = strs; // !!! Not allowed in Java
// ...
}

可以声明Source<? extends Object>来解决。

在Kotlin中,使用声明点变型(declaration-site variance)向编译器解释。使用out修饰符注解类型T,确保只返回(生产者)Source<T>成员,而从不写入(消费)。

abstract class Source<out T> {
abstract fun nextT(): T
}
fun demo(strs: Source<String>) {
val objects: Source<Any> = strs // This is OK, since T is an out-parameter
// ...
}

泛型规则:当类C的泛型参数T声明为out时,表示T只能出现在C成员的输出位置,作为交换,C<Base>C<Derived>类型安全的超类。

称类C是参数T的协变量,或T是协变量类型参数。可以认为类CT的生产者,而不是T的消费者。

out修饰符称为变型注解,因为它提供了类型参数声明点,因此称之为声明点类型。

除了out,kotlin提供了一个补充的变型注解:in。让类型参数变为逆变量:只能消费,从不生产。Comparable就是协变量一个很好的例子。

abstract class Comparable<in T> {
abstract fun compareTo(other: T): Int
}
fun demo(x: Comparable<Number>) {
x.compareTo(1.0) // 1.0 has type Double, which is a subtype of Number
// Thus, we can assign x to a variable of type Comparable<Double>
val y: Comparable<Double> = x // OK!
}

类型投影

使用处变型:类型投影
声明类型参数T为out很方便,避免在使用处子类型化。但一些类实际时无法限制只返回TArray就是一个很好的例子:

class Array<T>(val size: Int){
fun get(index: Int): T{ /*...*/}
fun set(index: Int , value: T){/*...*/}
}

Array类既不是T的协变,也不是T的逆变,导致不够灵活。考虑下面的函数:

fun copy(from: Array<Any> , to: Array<Any>){
assert(from.size == to.size)
for(i in from.indices)
to[i] = from[i]
}

函数应该是从拷贝数组中数据到另一个数组,下面将函数用在实际中:

val ints: Array<Int> = arrayOf(1, 2, 3)
val any = Array<Any>(3){ ""}
copy(ints , ant) // 错误:expects(Array<Any>, Array<Any>)

遇到了相同的问题:Array<T>是不变的,T类型的数组,所以Array<Int>Array<Any>都不是对方的子类。因为copy可能会坏事,可能会进行写操作,比如像from写入String,而实际上这里传入的是Int数组,运行时就能出现ClassCastException异常。

因此,只需要保证copy不会做坏事,禁止向from写数据,可以这样做:

fun copy(from: Array<out Any> , to: Array<Any>){
//...
}

这样做法被称为类型投影(type projection),也是说from不是一个简单数组,而是受限(投影)类型:只能够调用那些返回类型为T的方法,在这种情况意味着只能调用get,这也是使用使用出变型的目的,对应java的Array<? extends Object>,但是是通过一个更为简单的方法。

也可以使用in来投影类型

fun fill(dest: Array<in String> , value: String){
// ...
}

Array<in String>对应Java的Array<? super String>。如向fill函数传入CharSequenceObject数组。

星号投影

有时不知道类型参数任何信息,但仍希望安全地使用。此时安全地定义投影的泛型,每个泛型的具体实例都是泛型的子类型。
为此,Kotlin提供称为星号投影的语法

  • 对于Foo<out T>T为带有上界TUpper的协变量,Foo<*>等价于Foo<out TUpper>。意味着T类型未知时,可以安全地读取Foo<*>TUpper的值
  • 对于Foo<in T>T为逆变类型参数,Foo<*>等价于Foo<in Nothing>,意味着当T类型未知时,无法安全写入Foo<*>
  • 对于Foo<T>T为不可变类型参数,带有上界TUpperFoo<*>等价于Foo<out TUpper>用于读取和Foo<in Nothing>用于写入值。

如果泛型有多个类型参数,则每个都可以独立投影。比如,如果类型声明为interface Function<in T, out U>,可以设想下面的星号投影

  • Function<*, String> 意味 Function<in Nothing, String>
  • Function<Int, *> 意味 Function<Int, out Any?>
  • Function<*, *> 意味 Function<in Nothing, out Any?>

星号投影与Javaraw类型相似,但是安全。

泛型函数

不仅类可以有类型参数,函数也可以有。函数的类型参数在函数名之前声明:

fun <T> SingletonList(item: T ): List<T>{
// ...
}
fun <T> T.basicToString() : String { // 扩展函数
// ...
}

调用泛型函数,在调用的函数名之后指定具体类型参数

val l = SingletonList<Int>(1)

泛型约束

所有可以被指定类型参数替代的类型,都可以使用泛型约束进行限制。

上界

最常见的泛型约束就是上界,对应java的extends关键字

fun <T : Comparable<T>> sort(list: List<T>){
// ...
}

在冒号之后指定的类型就是上界,只有Comparable<T>子类才能替换T。如:

sort(listOf(1, 2, 3)) // 可以。Int是Comparable<Int>的子类
sort(listOf(HashMap<Int, String>())) // 错误。HashMap<Int, String>不是Comparable<HashMap<Int, String>>的子类

默认上界类型为Any?。尖括号中只允许指定一个上界。可使用where条件语句指定超过一个的上界

fun <T> cloneWhenGreater(list: List<T> , threshold: T): List<T>
where T : Comparable ,
T : Cloneable {
return list.filter{it -> threshold }.map { it.clone()}
}

参考

里氏替换原则

协变与逆变

泛型中的协变和逆变