Kotlin 泛型

作者: 郎官人 | 来源:发表于2017-09-27 16:15 被阅读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)

    声明处型变

    声明处的类型变异使用协变注解修饰符:inout,消费者 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 可能做坏事,也就是说,例如它可能尝试写一个 Stringfrom ,并且如果我们实际上传递一个 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> , 那么可以出现以下几种星号投射:

    1. Function<*, String> , 代表 Function<in Nothing, String> ;
    2. Function<Int, *> , 代表 Function<Int, out Any?> ;
    3. 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() }
    }
    

    相关文章

      网友评论

        本文标题:Kotlin 泛型

        本文链接:https://www.haomeiwen.com/subject/vjvuextx.html