《Kotlin入门实战》CH8 | 泛型

泛型

泛型是在Java5中引入的，泛型让集合框架可以重用代码，在没有泛型时候，集合框架中存储数据的类型都是Object，也就是说存入和取出数据都需要对对象进行强制类型转换。这就很可能出现错误。

1 类接口函数上使用泛型

泛型接口

interface Send<T>{
    fun handleMessage(t : T) : T;
}

fun main() {
    val h = object : Send<String>{
        override fun handleMessage(t: String): String {
            println(t)
            return "收到消息$t"
        }
    }
    println(h.handleMessage("hello"))
}

/*
hello
收到消息hello
*/

泛型类

class TClass<T>(var t : T){
    override fun toString(): String {
        return t.toString()
    }
}

fun main() {
    val t = TClass<Int>(1)
    println(t)
}

泛型函数

fun <T> handleT(t: T){
    println(t)
}

fun main() {   
    handleT<String>("nihao")
}

2 泛型上界

fun <T : Comparable<T>> gt(x: T, y: T): Boolean

<>中的T : Comparable<T>表示实现Comparable接口的类型

3 协变和逆变

协变

java中不支持协变，使用了通配符来解决的问题。

Number类型（简记为F）是Integer类型（简记为C）的父类型，我们把这种父子类型关系简记为C=>F（C继承F）；而List,List代表的泛型类型信息分别简记为f(F),f(C)。那么我们可以这样描述协变和逆变：
当C =>F时，如果有f(C) => f(F)，那么f叫做协变；
当C => F时，如果有f(F) => f(C)，那么f叫做逆变。如果上面两
种关系都不成立则叫做不变。

协变和逆变都是安全的。

Java中数组是可以协变的

        Integer[] ints = new Integer[3];
        ints[0] = 0;
        ints[1] = 1;
        ints[2] = 2;
        Number[] numbers = new Number[3];
        numbers = ints; //数组是协变的，可以正确赋值
        for (Number n : numbers) {
            System.out.println(n);
        }

java中泛型是不可以协变的

public class Test {
    static class A{

    }
    static class B extends A{

    }

    public static void main(String[] args) {
        List<B> bs = new ArrayList<>();
        bs.add(new B());
        List<A> as = (List<A>) bs; // Error Java泛型是不变的
    }
}

Error:(17, 32) java: 不兼容的类型: java.util.List<Test.B>无法转换为java.util.List<Test.A>

所以下面代码也是不合法的

List<Integer> integerList = new ArrayList<>();
integerList.add(0);
integerList.add(1);
integerList.add(2);
List<Number> numberList = new ArrayList<>();
numberList = integerList; //编译错误：类型不兼容

Java中泛型和数组的不同行为的确引起了许多混乱，就算我们使用通配符这样写：

List<? extends Number> list = new ArrayList<Number>();
list.add(new Integer(1)); //error

还是报错，不是说通配符可以解决协变问题吗

这个情况需要特殊说明，如果可以向List<? extends Number>中添加Integer，Float等，则意味着，List中存取的数据可以是integer, Float, Double等等，着就导致了List存储的元素类型混乱，所以Java禁止向List<? extends Number>中添加任意Number子类型的对象。但是可以添加Null指针。

逆变

java对逆变是支持的

逆变

    List<? super Integer> list = new ArrayList<Object>();
    list.add(Integer.valueOf(1));

PECS

总结 ? extends 和 the ? super 通配符的特征，我们可以得出以下结论：

• 如果你想从一个数据类型里获取数据，使用 ? extends 通配符
• 如果你想把对象写入一个数据结构里，使用 ? super 通配符
• 如果你既想存，又想取，那就别用通配符。

这就是Maurice Naftalin在他的《Java Generics and Collections》这本书中所说的存取原则，以及Joshua Bloch在他的《Effective Java》这本书中所说的PECS法则。

Bloch提醒说，这PECS是指”Producer Extends, Consumer Super”，这个更容易记忆和运用。

    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        int srcSize = src.size();
        if (srcSize > dest.size())
            throw new IndexOutOfBoundsException("Source does not fit in dest");

        if (srcSize < COPY_THRESHOLD ||
            (src instanceof RandomAccess && dest instanceof RandomAccess)) {
            for (int i=0; i<srcSize; i++)
                dest.set(i, src.get(i));
        } else {
            ListIterator<? super T> di=dest.listIterator(); // 写入数据
            ListIterator<? extends T> si=src.listIterator(); // 读取数据
            for (int i=0; i<srcSize; i++) {
                di.next();
                di.set(si.next());
            }
        }
    }

在kotlin中直接使用in和out来代替super和extends

out T等价于? extends T；
in T等价于? super T。

4 类型擦除

对于JVM来说并不存在List<Integer> ，JVM中只存在List，Kotlin也是这样的。

类型擦除的基本过程也比较简单：

1. 首先，找到用来替换类型参数的具体类。这个具体类一般是Object。如果指定了类型参数的上界的话，则使用这个上界。
2. 其次，把代码中的类型参数都替换成具体的类。同时去掉出现的类型声明，即去掉<>的内容。例如，Tget()就变成了Objectget()，List就变成了List。
3. 最后，根据需要生成一些桥接方法。这是由于擦除了类型之后的类可能缺少某些必须的方法。这个时候就由编译器来动态生成这些方法。