Kotlin（1.1）学习笔记（6）——泛型

2019年7月7日 143次阅读 来源: Rhett_S

in和out

和java一样，kotlin中也有泛型的概念。不同的是，java中使用了通配符而kotlin中不存在。本文主要介绍两者的不同之处。
java中为了解决

List<String> strs = new ArrayList<String>();
List<Object> objs = strs;

类似语句中strs复制objs报错的问题，使用了通配符，如常见的<? extends Object>,<? super Object>；在kotlin中则要在使用泛型出out和in来限定泛型是否允许插入和读取。in修饰的泛型只能写入，out修饰的泛型只能读取。
举个例子：
我们定义一个copy方法，将第一个数组的内容拷贝到第二个数组中去

val ints: Array<Int> = arrayOf(1, 2, 3)
val any = Array<Any>(3)
copy(ints, any)

错误示例一：
fun copy(from: Array<Any>, to: Array<Any>) {
    assert(from.size == to.size)
    for (i in from.indices)
        to[i] = from[i]
}
这里调用copy(ints, any) // 错误：期望 (Array<Any>, Array<Any>)，

因为Array<Int>不是Array<Any>的子类，编译器认为我们可能修改里面的信息，向其中加入非Any类型的对象，所以报错

正确示例一
fun copy(from: Array<out Any>, to: Array<Any>) {
 // ……
}

这个函数和上面那个唯一的不同就是参数from中增加了out关键字，它等同于java中的<? extends object>表明from这个对象是能用来做source，并读取里面的信息，不能向内增加数据

同样的，我们也可以为第二个参数增加修饰的in，等同于java中的<? super Object>，to只能接收Any以及其父类（ps：在本例中，虽然可以通过编译器，但是这样写已经无意义）
正确示例二

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

根据官网的介绍，我们可以把from称作生产者，to成为消费者。

星投影

看到这里我们已经学到了它们的基本用法，下面来将两个特殊的星投影

  • 对于 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 是一个具有上界 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?>。

注意：星投影非常像 Java 的原始类型，但是安全。

(以下内容官网已经将的很详细，这里直接照抄)

泛型函数

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

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)) // 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() }
}
    原文作者：Rhett_S
    原文地址: https://www.jianshu.com/p/1fd86f40231c
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞