《Kotlin入门实战》CH8 | 泛型

泛型

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

1 类接口函数上使用泛型

泛型接口

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

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

/*
hello
收到消息hello
*/

泛型类

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

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

泛型函数

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

fun main() {   
    handleT("nihao")
}

2 泛型上界

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

<>中的T : Comparable表示实现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 bs = new ArrayList<>();
        bs.add(new B());
        List as = (List) bs; // Error Java泛型是不变的
    }
}
Error:(17, 32) java: 不兼容的类型: java.util.List无法转换为java.util.List

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

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

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

List list = new ArrayList();
list.add(new Integer(1)); //error

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

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

逆变

java对逆变是支持的

逆变
    List list = new ArrayList();
    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  void copy(List dest, List 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 di=dest.listIterator(); // 写入数据
            ListIterator si=src.listIterator(); // 读取数据
            for (int i=0; i

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

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

4 类型擦除

对于JVM来说并不存在List ,JVM中只存在List,Kotlin也是这样的。

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

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

你可能感兴趣的:(《Kotlin入门实战》CH8 | 泛型)