Kotlin 泛型

说起 kotlin 的泛型，就离不开 java 的泛型，首先来看下 java 的泛型，当然比较熟悉 java 泛型的同学可以跳过这一块的内容。

java 泛型

首先，java 提出泛型的概念，是为了解决能够存储各种对象的容器，同时希望这个容器尽可能的是类型安全的，当然这个类型安全，也就是参数类型化，可能只是编译期的类型安全，因为 java 的泛型，是对比 C# 等泛型，在运行期间是类型擦除的，什么是类型擦除，后面再说。

实际上 java 提出泛型，大概是为了增强以下场景的语言能力：

• 类型安全的对象容器
• 通过泛型类型，可以构建类型安全的方法或者接口

java 的泛型，对比 C# 只是在编译器层次的类型检测，帮助开发构建更安全的类型检测代码，同时减少类型强转和类型判断的代码，提高开发效率。

为什么说，java 的泛型是在编译器层次的类型检测，也就是类型擦除，我们看一个例子：

先来看一段 java 代码：

        ArrayList list = new ArrayList();
        list.add("11");
        String str = list.get(0);

然后看下实际的字节码

  public test1()V
   L0
    LINENUMBER 9 L0
    NEW java/util/ArrayList
    DUP
    INVOKESPECIAL java/util/ArrayList. ()V
    ASTORE 1
   L1
    LINENUMBER 10 L1
    ALOAD 1
    LDC "11"
    INVOKEVIRTUAL java/util/ArrayList.add (Ljava/lang/Object;)Z
    POP
   L2
    LINENUMBER 11 L2
    ALOAD 1
    ICONST_0
    INVOKEVIRTUAL java/util/ArrayList.get (I)Ljava/lang/Object;
    CHECKCAST java/lang/String
    ASTORE 2
   L3
    LINENUMBER 12 L3
    RETURN
   L4
    LOCALVARIABLE this Lcom/yy/yylite/kotlinshare/generics/JGTest; L0 L4 0
    LOCALVARIABLE list Ljava/util/ArrayList; L1 L4 1
    // signature Ljava/util/ArrayList;
    // declaration: list extends java.util.ArrayList
    LOCALVARIABLE str Ljava/lang/String; L3 L4 2
    MAXSTACK = 2
    MAXLOCALS = 3

我们看到的是：

//实际存入的是 Object
INVOKEVIRTUAL java/util/ArrayList.add (Ljava/lang/Object;)Z
//取出来的时候，居然做了类型检测
  CHECKCAST java/lang/String

那么实际上，编译器看到的还是一个 Object，那么这样会有什么问题呢？比如说，我一旦在某个地方，失去编译器检查的约束，这里就会发生问题，如下：

private void test(){
    List list =getSomeList();//这里拿到的是之前那个 ArrayList list = new ArrayList();
    list.add(9);//实际上add 进去的是一个 Integer
}

那么最终如果这个元素被 get 出来，并且当做 String 类型的话，就会报错。

所以到现在，基本知道类型擦除是怎么回事了吧；就是 java 的泛型，在编译期是可见的，但是实际运行期，是没有类型的。

所以在使用 Gson 过程中，我们序列化，需要传一个 Class 类型过去，然后根据 Class 的类型：

public  T fromJson(JsonElement json, Class classOfT) throws JsonSyntaxException {
  Object object = fromJson(json, (Type) classOfT);
  return Primitives.wrap(classOfT).cast(object);
}

字节码使用工具查看 android studio 插件-查看java/kotlin 字节码

java 泛型参考文章：泛型：工作原理及其重要性

java 泛型的其它细节

有界类型

java 中的泛型可以指定上限和下界，也就是通过 extends 和 super 关键字指定类型语法如下：

指定参数类型为 UpperBoundType类型或者其子类

指定参数类型为 UpperBoundType类型或者其父类

public  void getG(T in) {
    Log.i("jh",in.getClass().toString());
}

但是最终在字节码里面，我们看到的是：

  public getG(Ljava/lang/String;)V
   L0
    LINENUMBER 16 L0
    LDC "jh"
    ALOAD 1
    INVOKEVIRTUAL java/lang/Object.getClass ()Ljava/lang/Class;
    INVOKEVIRTUAL java/lang/Class.toString ()Ljava/lang/String;
    INVOKESTATIC android/util/Log.i (Ljava/lang/String;Ljava/lang/String;)I
    POP
   L1
    LINENUMBER 17 L1
    RETURN
   L2
    LOCALVARIABLE this Lcom/yy/yylite/kotlinshare/generics/JGTest; L0 L2 0
    LOCALVARIABLE in Ljava/lang/String; L0 L2 1
    // signature TT;
    // declaration: in extends T
    MAXSTACK = 2
    MAXLOCALS = 

这里实际的类型，就是 String。

通配符

java 中使用 ? 作为泛型的通配符，表示未知类型比如这样子的:

private void test3(List list) {
    Object obj = list.get(0);
}

实际上，字节码里的类型，也是 Object 类型。

kotlin 泛型

kotlin 的泛型和 java 的泛型基本是一样的，但是会有一些更好的特性。

Kotlin 中没有通配符，如果你要声明一个接受任何类型，可以用 Any 作为类型；

kotlin 协变和逆变

先来了解下协型变和逆变的概念，根据维基百科描述：

在一门程序设计语言的类型系统中，一个类型规则或者类型构造器是：

• 协变（covariant），如果它保持了子类型序关系≦。该序关系是：子类型≦基类型。
• 逆变（contravariant），如果它逆转了子类型序关系。
• 不变（invariant），如果上述两种均不适用。

协变与逆变

java 中使用这样的语法，表示可以容纳某个子类及其类型：

boolean addAll(Collection c);

这里实际是 Collection 接口里面的 addAll() 方法，表示该容器可以存储类型E及其子类。

在kotlin 中，提供了类似的功能，就是型变和协变。

在 java 代码中：

//这是一个泛型接口
public interface JSource {
    T next();
}
//然后某处调用
 private void test5(JSource strs){
    JSource