说起 kotlin 的泛型，就离不开 java 的泛型，首先来看下 java 的泛型，当然比较熟悉 java 泛型的同学可以跳过这一块的内容。
java 泛型
首先，java 提出泛型的概念，是为了解决能够存储各种对象的容器，同时希望这个容器尽可能的是类型安全的，当然这个类型安全，也就是参数类型化，可能只是编译期的类型安全，因为 java 的泛型，是对比 C# 等泛型，在运行期间是类型擦除的，什么是类型擦除，后面再说。
实际上 java 提出泛型，大概是为了增强以下场景的语言能力：
- 类型安全的对象容器
- 通过泛型类型，可以构建类型安全的方法或者接口
java 的泛型，对比 C# 只是在编译器层次的类型检测，帮助开发构建更安全的类型检测代码，同时减少类型强转和类型判断的代码，提高开发效率。
为什么说，java 的泛型是在编译器层次的类型检测，也就是类型擦除，我们看一个例子：
先来看一段 java 代码：
ArrayList<String> 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.<init> ()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<Ljava/lang/String;>;
// declaration: list extends java.util.ArrayList<java.lang.String>
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<String> list = new ArrayList();
list.add(9);//实际上add 进去的是一个 Integer
}
那么最终如果这个元素被 get 出来，并且当做 String 类型的话，就会报错。
所以到现在，基本知道类型擦除是怎么回事了吧；就是 java 的泛型，在编译期是可见的，但是实际运行期，是没有类型的。
所以在使用 Gson 过程中，我们序列化，需要传一个 Class 类型过去，然后根据 Class 的类型：
public <T> T fromJson(JsonElement json, Class<T> classOfT) throws JsonSyntaxException {
Object object = fromJson(json, (Type) classOfT);
return Primitives.wrap(classOfT).cast(object);
}
字节码使用工具查看 android studio 插件-查看java/kotlin 字节码
java 泛型参考文章：泛型：工作原理及其重要性
java 泛型的其它细节
有界类型
java 中的泛型可以指定上限和下界，也就是通过 extends 和 super 关键字指定类型语法如下：
<T extends UpperBoundType> 指定参数类型为 UpperBoundType类型或者其子类
<T super LowerBoundType> 指定参数类型为 UpperBoundType类型或者其父类
public <T extends String> 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<? extends E> c);
这里实际是 Collection 接口里面的 addAll() 方法，表示该容器可以存储类型E及其子类。
在kotlin 中，提供了类似的功能，就是型变和协变。
在 java 代码中：
//这是一个泛型接口
public interface JSource<T extends Object> {
T next();
}
//然后某处调用
private void test5(JSource<String> strs){
JSource<Object> objectSource = strs;//但是这里是不行的提示报错，require JSource<Object>,Found JSource<String>
}
所以java 不是协变的，也就是Java 的容器类的类构造器是不变的，String 是 Object 的子类，但是JSource<String> 和 JSource<Object> 并没有任何关系。
然而 Java 的数组是协变的，也就是存在这样一种情况，代码如下：
private void test6() {
Animal[] animals = new Animal[3];
animals = new Dog[5];
}
所以这里 Dog 是 Animal 的子类，但是 Animal[] 可以接受子类数组 Dog[] 的赋值，所以这里 java 的数组就是协变的。再来看下这里的字节码：
private test6()V
L0
LINENUMBER 39 L0
ICONST_3
ANEWARRAY com/yy/yylite/kotlinshare/generics/Animal
ASTORE 1
L1
LINENUMBER 40 L1
ICONST_5
ANEWARRAY com/yy/yylite/kotlinshare/generics/Dog
ASTORE 1
L2
LINENUMBER 41 L2
RETURN
L3
LOCALVARIABLE this Lcom/yy/yylite/kotlinshare/generics/JGTest; L0 L3 0
LOCALVARIABLE animals [Lcom/yy/yylite/kotlinshare/generics/Animal; L1 L3 1
MAXSTACK = 1
MAXLOCALS = 2
在 kotlin 中提供了协变和逆变声明来补充 java 数据容器不变的特性，使用关键字 out 和 in。
例如在 Collection 接口中：
public interface Collection<out E> : Iterable<E> {
override fun iterator(): Iterator<E>
public fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean
}
<out E> 则声明该集合的元素型变的，也就是协变，意味着如果Dog 是 Animal 的子类，则Collection<Dog> 是 Collection<Animal> 的子类。
所以通过 out 关键来声明 kotlin 的某个集合是协变的，那么你也可以使用 in 作为逆变符号说明，如下：
interface KGTest<in Dog> {
fun getDogInfo()
}
@UnsafeVariance
我们可以通过这个 @unsafeVariance 来忽略编译器的类型坚持，直接使用泛型， UnsafeVariance 的声明如下：
/**
* Suppresses errors about variance conflict
*/
@Target(TYPE)
@Retention(SOURCE)
@MustBeDocumented
public annotation class UnsafeVariance
泛型边界
在 java 中，通过 extend 去限定泛型边界，如下：
boolean addAll(Collection<? extends E> c);
表示该元素都是继承自 E 的，在 kotlin 中，也可以支持这类边界，如下：
fun <T : Animal> addAnimal()
当然如果是多个边界，你可以用 where 语句：
interface TWhere<T> where T : Number, T : Cloneable {
}
则便是说明，需要多个边界同时满足。
reified 具体化的类型参数
使用反射的时候，我们需要传一个 Class 类型进去，在 kotlin 中，有这样个操作，先看例子：
class GsonExtension {
fun testRefied() {
val jsonStr = "{\n" +
"\tid:\"7788\",\n" +
"\tname:\"kslsl\",\n" +
"\tdistict:99\n" +
"}"
val dInfo = Gson().fromEasyJson<ForDInfo>(jsonStr)
}
}
inline fun <reified T> Gson.fromEasyJson(json: String): T {
return fromJson(json, T::class.java)
}
data class ForDInfo(
val distict: Int,
val id: String,
val name: String
)
我们通常在 java 中使用 Gson 去反射生成对象，都需要传一个 Class 对象，但是在 kotlin 中，你使用 inline 和 reified,则可以不用传这个 Class 对象。
参考地址：具体化的类型参数
网友评论