Kotlin 泛型

2017-09-27 本文已影响0人郎官人

与Java一样，Kotlin也支持泛型，为类型安全提供保证，消除类型强转的烦恼

class User<T>{
        var type :T ?=null
}

创建类的实例时我们需要指定类型参数:

val box: Box<Int> = Box<Int>(1)
// 或者
val box = Box(1) // 编译器会进行类型推断，1 类型 Int，所以编译器知道我们说的是 Box<Int>。

定义泛型类型变量，可以完整地写明类型参数，如果编译器可以自动推定类型参数，也可以省略类型参数。

型变

在此之前，我们先来看一看Java中的通配符。

首先，Java中的泛型是不型变的，这意味着 List<String> 并不是 List<Object> 的子类型。这是因为Java中如果可以型变，那么就会出现如下：

public static void main(String [] args){
        //Java
        List<String> strs = new ArrayList<>();
        List<Object> objs = strs;//编绎器报错
        //如果不报错，我们可以
        objs.add(1);//将整数放入字符串集合中
        String s = strs.get(0);//!!!ClassCastException 无法将整型转为字符串
}

因此，Java 禁止这样的事情以保证运行时的安全。但这样会有一些影响：比如将String类型的集合添加到Object类型的集合中,因为String是Object的子类，这个操作其实是完全安全的。

但是我们看到Java源码中是这样定义的：

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

我们将它改成这样的话：

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

我们希望可以达成这样的操作：

// Java
void copyAll(Collection<Object> to, Collection<String> from) {
to.addAll(from); // ！！！对于这种简单声明的 addAll 将不能编译：
// Collection<String> 不是 Collection<Object> 的子类型
}

Java的通配符类型参数 {? extends E} 表示此方法接受 E 或者 E 的一些子类型对象的集合，而不只是 E 自身。这意味着我们可以安全地从其中（该集合中的
元素是 E 的子类的实例）读取 E ，但不能写入，因为我们不知道什么对象符合那个未知的 E 的子类型。反过来，该限制可以让 Collection<String> 表示为 Collection<? extends Object> 的子类型。简而言之，带extends限定（上界）的通配符类型使得类型是协变的（covariant）。

在来看下面一段代码：

public void genericCode(){
        //Java
        List<? extends String> texts = new ArrayList<>();
        texts.add("dd");//出错--不可写
        String s = texts.get(0);//可读

        List<? super String> spans = new ArrayList<>();

        spans.add("ddddd");//可以写入
        String s = spans.get(0);//出错--不可读
}

理解为什么这个技巧能够工作的关键相当简单：如果只能从集合中获取项目，那么使用String 的集合，并且从其中读取Object也没问题。反过来，如果只能向集合中放入项目，就可以用Object 集合并向其中放入 String ：在 Java 中 List<? super String> 是 List<Object> 的一个超类。后者称为逆变性（contravariance）

但是在Kotlin中并没有通配符这种东西，但是它有：

声明处型变 （declaration-site variance）
类型投影 （type projections）

声明处型变

声明处的类型变异使用协变注解修饰符：in、out，消费者 in, 生产者 out。

使用 out 使得一个类型参数协变，协变类型参数只能用作输出，可以作为返回值类型但是无法作为入参的类型：

// 定义一个支持协变的类
class Runoob<out A>(val a: A) {
    fun foo(): A {
        return a
    }
}

fun main(args: Array<String>) {
    var strCo: Runoob<String> = Runoob("a")
    var anyCo: Runoob<Any> = Runoob<Any>("b")
    anyCo = strCo
    println(anyCo.foo())   // 输出 a
}

in 使得一个类型参数逆变，逆变类型参数只能用作输入，可以作为入参的类型但是无法作为返回值的类型:

// 定义一个支持逆变的类
class Runoob<in A>(a: A) {
    fun foo(a: A) {
    }
}

fun main(args: Array<String>) {
    var strDCo = Runoob("a")
    var anyDCo = Runoob<Any>("b")
    strDCo = anyDCo
}

下面有两个与Java对照的实例，可以加深这种理解

    //Kotlin
    interface Source<out T>{

        fun data():Source<T>
    }

    class DataSource :Source<Any>{
        
        val source :Source<String>= ...
        
        override fun data(): Source<Any> {
            return source;
        }
    }

//Java
interface Source<T>{

    Source<T> data();

}

class DataSource implements Source<Object>{

    Source<String> source = null;
    
    @Override
    public Source<Object> data() {
        return source;//!!!不允许，抛错
    }
}

再来：

//Kotlin
interface Box<in T>{

    fun set(t:T)
}

fun doIt(box:Box<Number>){
    box.set(1.0)//1.0 拥有类型 Double，它是 Number 的⼦类型
    // 因此，我们可以将 box 赋给类型为 Box <Double> 的变量
    var dBox :Box<Double> = box
}

//Java
    interface Box<T>{
        
        void set(T t);
    }
    
    void doIt(Box<Number> box){
        box.set(1.0);
        Box<Double> dBox = box;//!!!IDE提示出错
    }

类型投影

Kotlin中有时也会遇到跟Java一样的尴尬，很好的例子就是 Array，我们来看看 Array 的源码：

public class 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, any) // 错误：期望 (Array<Any>, Array<Any>)

因为 copy 可能做坏事，也就是说，例如它可能尝试写一个 String 到 from ，并且如果我们实际上传递一个 Int 的数组，一段时间后将会抛出一个
ClassCastException 异常。

那么，我们唯一要确保的是 copy() 不会做任何坏事。我们想阻止它写到 from ，我们可以：

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

这里from成为了一个受限制的（投影的）数组，我们只可以调用返回类型为类型参数 T 的方法，如上，这意味着我们只能调用get()。这就是我们的使用处型变的方法，并且是对应于 Java 的 Array<? extends Object> 、但使用更简单些的方式。

我们称其为类型投影

再使用 in 作一个投影

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

Array<in String> 对应于 Java 的 Array<? super String> ，也就是说，你可以传递一个 CharSequence 数组或一个 Object 数组给fill() 函数。

星号投影

有些时候, 你可能想表示你并不知道类型参数的任何信息, 但是仍然希望能够安全地使用它. 这里所谓"安全地使用"是指, 对泛型类型定义一个类型投射, 要求这个泛型类型的所有的实体实例, 都是这个投射的子类型。
对于这个问题, Kotlin 提供了一种语法, 称为星号投影(star-projection):

假如类型定义为 Foo<out T> , 其中 T 是一个协变的类型参数, 上界(upper bound)为 TUpper ,Foo<*> 等价于 Foo<out TUpper> . 它表示, 当 T 未知时, 你可以安全地从 Foo<*> 中读取TUpper 类型的值.
假如类型定义为 Foo<in T> , 其中 T 是一个反向协变的类型参数, Foo<*> 等价于 Foo<in Nothing> . 它表示, 当 T 未知时, 你不能安全地向 Foo<*> 写入任何东西.
假如类型定义为 Foo<T> , 其中 T 是一个协变的类型参数, 上界(upper bound)为 TUpper , 对于读取值的场合, Foo<*> 等价于 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?> .

Note :星号投射与 Java 的原生类型(raw type)非常类似, 但可以安全使用

泛型函数

不仅类可以有类型参数。函数也可以有。类型参数要放在函数名称之前：

fun <T> singletonList(item: T): List<T> {
// ……
} f
un <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)) // OK。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() }
}