泛型在Java和Kotlin中的细微区别，你Get到了吗？

码农 | 章磊

“人应当相信，不了解的东西总是可以了解的，否则他就不会再去思考。”

哥德

在文章《泛型漫谈》中我们曾讲过泛型的基础知识，这里不再赘述。

那么这篇文章主要讲泛型在Java和Kotlin中区别，可能你在Java中泛型玩得很6，在Kotlin中就不好使了。好了，费话不多说，开讲啦~

一、泛型参数的缺省

我们知道，Java中泛型可以不指定泛型参数，比如以下代码是可以编译通过的。

List list = new ArrayList();

其效果与下面一样：

List list = new ArrayList<Object>();

而Java之所以这样搞，据小道消息，是为了兼容1.5以前还没有泛型的版本。

那Kotlin中也可以这样玩吗？明显不行！！！

根据提示，必须显示地提供泛型参数信息。

那为什么Kotlin不用往后兼容捏？因为它是基于Java1.6，即天然拥有泛型，可以从源头控制必须指定泛型。

虽然说Kotlin中必须指定泛型参数，但由于它可以类型推导，所以以下写法也是允许的。

val arrayList = arrayListOf("A", "B") // 等价于val arrayList = arrayListOf<String>("A", "B")

二、不变、协变、逆变

关于这几个概念，我们从其他地方复制下：

逆变与协变用来描述类型转换（type transformation）后的继承关系，其定义：如果𝐴、𝐵表示类型，𝑓(⋅)表示类型转换，≤表示继承关系（比如，𝐴≤𝐵表示𝐴是由𝐵派生出来的子类）；
𝑓(⋅)是逆变（contravariant）的，当𝐴≤𝐵时有𝑓(𝐵)≤𝑓(𝐴)成立；
𝑓(⋅)是协变（covariant）的，当𝐴≤𝐵时有𝑓(𝐴)≤𝑓(𝐵)成立；
𝑓(⋅)是不变（invariant）的，当𝐴≤𝐵时上述两个式子均不成立，即𝑓(𝐴)与𝑓(𝐵)相互之间没有继承关系。

看晕了没关系，举个粟子就清楚了，比如在Java中：

形如Type<T>就是不变；
形如Type<? extends T>就是协变；
形如Type<? super T>就是逆变；

那Kotlin中其实也有对应的表示：

    class KC1<T> {} // 不变
    class KC2<out T> {} // 协变
    class KC3<in T> {} // 逆变

乍一看，把写法替换下就好了，其实还是有差别的。
比如，在Java的协变中是可以直接以T作为入参：

class JC2<T extends Number> {
    /**
     * 可以有T类型的形参
     * @param t
     */
    void f(T t) {
        System.out.println(t);
    }
}

而在Kotin中是默认不允许的：

class KC2<out T: Number> {
    /**
     * 不可以有T类型形参
     */
    fun f(t: T) {
        print(t)
    }
}

如果一定要这样的话，可以加上UnsafeVariance的注解。

 fun f(t: @UnsafeVariance T) {
        print(t)
    }

其实从out这个关键字就知道，T仅作为返回值输出，输入是不应该的。
同理，逆变中Kotlin使用了in这个关键字，所以可以用作参数，但不应该用作返回，具体大家可以试试。

关于数组的协变，Java和Kotlin中也是不同的。

在Java中可以写出这样的代码：

Integer[] values = new Integer[5];
Number[] numbers = values;

说明Java中数组是支持协变的。

如果我们用同样的思维在Kotlin这样写的话，就会出错：

val values = arrayOf(1, 2, 3, 4)
val numbers: Number = values // Error: type mismatch.

然后对于集合Collection，Java是不支持协变，Kotlin中反倒是支持的，比如下面代码也没编译问题。

val values = ArrayList<Int>()
val numbers: List<Number> = values

我们分别查看List的源码：

public interface List<E> extends Collection<E> { // Java E
public interface List<out E> : Collection<E> // Kotlin out E

那么Kotlin中不担心下面代码引起的ArrayStoreException吗？

val values = ArrayList<Int>()
val numbers: List<Number> = values
numbers.add(3.14F) // Kotlin中List不支持add

其实不必担心，因为Kotlin中的List不支持写操作，所以压根不存在所谓的存储异常。

三、多约束

在Java中，如果要求泛型参数T继承ClassA，并且实现接口InterfaceB的话，我们只能再写一个类ClassC去继承ClassA，实现InterfaceB，如图。

interface InterfaceB {
}

class ClassC extends ClassA implements InterfaceB {
}

class JC2<T extends ClassC> {
}

所以可以大胆地说，Java对泛型参数不支持多约束。

那号称“更好的Java”的Kotlin呢？

fun <T> f(t: @UnsafeVariance T) where T:ClassA, T: InterfaceB{
   print(t)
}

立马感觉简洁了很多！

四、获取泛型参数类型

我们知道泛型参数信息在编译后是会被擦除的，也就是说理论上在运行时是无法拿到泛型参数类型的。

然而……擦除并不是被抹得一干二净，在class的常量仍然可以拿到泛型相关信息。

而匿名内部类在初始化时会绑定父类或父接口相关信息，所以无论在Java还是Kotlin中我们都可以通过这种方式拿到泛型参数类型，只是写法不同罢了。

// Java版本
class JGenericsToken<T> {
    Type type;
    public JGenericsToken() {
        type = ((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];
//        System.out.println(type);
    }
}

// 测试
@Test
public void testGeneric() {
    // Java
    System.out.println(new JGenericsToken<String>(){}.type);
}
// 输出
class java.lang.String

// Kotlin版本
open class GenericToken<T> {
    var type: Type? = null

    init {
        var superClass = this.javaClass.genericSuperclass
        type = (superClass as ParameterizedType).actualTypeArguments[0]
    }
// 测试
    @Test
    fun testGeneric() {
        val obj = object : GenericToken<String>(){}
		print(obj.type)
    }

其实Gson中就是这样实现的。

除此之外，在Kotlin中我们还可以通过内联函数配合reified关键字获取参数类型。

inline fun <reified T> getType() {
	return T:class:java
}

五、通配符

关于通配符没什么好说的，就是Java中用"?"，Kotlin中用"*"。
只要记住Java中Type<?>相当于Type<? extends Object>.
Kotlin中，Type<*>相当于Type<out Any?>。

好了，今天就讲这么多啦，码字不易，看到这里的朋友记得点个赞哈~