[TOC] ## 泛型擦除与实化类型 ### 泛型擦除 由于**JVM虚拟机中没有泛型**，因此**泛型类的类型在编译时都会被擦除**，所谓的**擦除是指当定义一个泛型时，例如`List＜String＞`类型，运行时它只是List，并不体现String类型**。这一点Kotlin与Java是一样的，**泛型类实例的类型实参在运行时都会被擦除**。 接下来我们通过一个案例来解释泛型在程序运行时会被擦除，具体代码如下所示。 ``` fun main(args: Array<String>) { //定义一个类型为List<String>的集合 val list1 = listOf("a", "b", "c") //定义一个类型为List<Int>的集合 val list2 = listOf(1, 2, 3) //打印集合的类型 println(list1.javaClass) println(list2.javaClass) //判断这两个集合数据类型是否一致 println(list1.javaClass == list2.javaClass) } ``` 运行结果： ``` class java.util.Arrays$ArrayList class java.util.Arrays$ArrayList true ``` 根据运行结果可知，**List＜String＞和List＜Int＞在程序运行期间类型是一样的，因此说明泛型在运行时都会被擦除**。  图在运行时，你不会知道listl 和l ist2 是否声明成字符串或者整数列表。它们每个都只是List。 即使编译器看到的是两种完全不同类型的列表，在执行的时候它们看起来却完全一样。尽管如此，你通常可以确信`List<String>`只包含字符串，而`List<Int>`只包含整数。因为编译器知道类型实参，并确保每个列表中只存储正确类型的元素（可以通过类型转换或使用Java 原生态类型访问列表，来欺骗编译器，但你需要特意这样做）。 一般而言，在is 检查中不可能使用类型实参中的类型。下面这样的代码不会编译： ``` >>> if (value is List<String>) { ... } ERROR: Cannot check for instance of erased type ``` 尽管在运行时可以完全断定这个值是一个List ，但你依然无法判断它是一个含有字符串的列表，还是含有人，或者含有其他什么： 这些信息被擦除了。注意擦除泛型类型信息是有好处的：应用程序使用的内存总量较小，因为要保存在内存中的类型信息更少。 ### 泛型通配符 在Java程序中，如果**不知道泛型的具体类型时**，可以用“?”通配符来代替具体的类型，而**在Kotlin中则使用“`*`”来代替泛型的具体类型，这个“`*`”就被称为泛型通配符，它只能在“＜＞”中使用**。 接下来我们通过一个案例演示如何使用泛型通配符“*”，具体代码如下所示。 ``` open class Food(val name: String) open class Flower(val name: String) class Rice : Food("大米") class Rose : Flower("玫瑰") class Container<T>(var content: T) //定义一个泛型类Container fun printInfo(container: Container<*>) { val content = container.content if (content is Food) { println(content.name) } else if (content is Flower) { println(content.name) } } fun main(args: Array<String>) { val riceContainer = Container<Rice>(Rice()) val roseContainer = Container<Rose>(Rose()) printInfo(riceContainer) printInfo(roseContainer) } ``` 运行结果： ``` 大米 玫瑰 ``` 上述代码中，通过printInfo()方法来打印Container泛型类中传递的食物或者鲜花，printInfo()方法可以接收`Container＜out Food＞`也可以接收`Container＜out Rose＞`，**由于不能明确需要传入的是什么类型，因此使用“`*`”代替**。 在main()函数中，分别创建了两个泛型类Container的实例对象—riceContainer和roseContainer，其中riceContainer传递的参数类型为Rice，roseContainer传递的参数类型为Rose，将这两个实例对象传递到printInfo()方法中即可打印运行结果。 >[success] **多学一招：星投影** **当对泛型的实参一无所知，但仍然希望用安全的方式使用它时，此时有一种安全的方式——星投影，星投影就是将泛型中的“*”等价于泛型中的注解out与in对应的协变类型参数与逆变类型参数，泛型的每个具体实例化将是该投影的子类型，Kotlin为此提供了星投影语法**，我们以自定义的泛型类`A＜T＞`为例来演示星投影语法，具体如下。 （1）对于泛型类`A＜out T＞`，其中T是一个具有上界TUpper的协变类型参数，`A＜*＞`等价于`A＜out TUpper＞`，这意味着当T未知时，可以安全地从`A＜*＞`中读取TUpper的值。 （2）对于泛型类`A＜in T＞`，其中T是一个逆变类型参数，`A＜*＞`等价于`A＜in Nothing＞`，**由于Nothing类型表示没有任何值，因此这意味着当T未知时，没有安全的方式写入`A＜*＞`**。 （3）对于泛型类`A＜T＞`，其中T是一个具有上界TUpper的**不型变类型参数**，`A＜*＞`在读取值时等价于`A＜out TUpper＞`，而在写值时等价于`A＜in Nothing＞`。 如果**泛型类型具有多个类型参数**，则**每个类型参数都可以进行单独的星投影**，例如，如果声明一个泛型类`B＜in T,out U＞`，则此时可以根据星投影语法推测出以下星投影。 > * 如果泛型类为B＜*, String＞，则该泛型类等价于B＜in Nothing, String＞。 > * 如果泛型类为B＜Int,*＞，则该泛型类等价于B＜Int, out Any?＞。 > * 如果泛型类为B＜*,*＞，则该泛型类等价于B＜in Nothing, out Any?＞。 示例：对泛型类型做类型转换  编译一切正常：编译器只是发出了一个警告，这意味着代码是合法的。如果在一个整型的列表或者set 上调用printSum 函数， 一切都会如预期发生：第一种情况会打印出元素之和，而第二种情况则会抛出IllegalArgumentException 。但如果你传递了一个错误类型的值，运行时会得到一个ClassCastException  ### 实化类型 前面已经讲过**泛型在运行时会被擦除，这样就无法知道某一个泛型形参在使用时具体是什么类型的泛型实参**，在Java中，可以通过反射**获取泛型的真实类型**，而**在Kotlin中，要想获取泛型的实参类型，则需要在内联函数（inline关键字定义的函数）中使用reified关键字修饰泛型参数才可以，这样的参数称为实化类型**。 >[success]**注意**：reified关键词必须要和inline一起使用，因为**只有内联的泛型函数才可以在运行时获取泛型实参的类型**。 可能有点懵逼，待我细细道来。 由于 Java 中的泛型存在类型擦除的情况，任何在运行时需要知道泛型确切类型信息的操作都没法用了。Java泛型里的类型参数，也就是这个T，它不是真正的类型，只是一个代号，所以你不能把它当成一个普通的类型来用，比如你不能在方法里检查一个对象是不是一个T的实例。这个在kotlin和Java都是一样的。 比如你不能检查一个对象是否为泛型类型`T`的实例： ~~~java ☕️ <T> void printIfTypeMatch(Object item) { if (item instanceof T) { // 👈 IDE 会提示错误，illegal generic type for instanceof System.out.println(item); } } ~~~ Kotlin 里同样也不行： ~~~kotlin 🏝️ fun <T> printIfTypeMatch(item: Any) { if (item is T) { // 👈 IDE 会提示错误，Cannot check for instance of erased type: T println(item) } } ~~~ 这个问题，在 Java 中的解决方案通常是额外传递一个`Class<T>`类型的参数，然后通过`Class#isInstance`方法来检查： ~~~java ☕️ 👇 <T> void check(Object item, Class<T> type) { if (type.isInstance(item)) { 👆 System.out.println(item); } } ~~~ Kotlin 中同样可以这么解决，不过还有一个更方便的做法：使用关键字`reified`配合`inline`来解决： ~~~kotlin 🏝️ 👇 👇 inline fun <reified T> printIfTypeMatch(item: Any) { if (item is T) { // 👈 这里就不会在提示错误了 println(item) } } ~~~ 接下来我们通过一个在Any类中添加一个拓展方法isType()的案例来判断泛型的实参类型，具体代码如下所示。 ``` inline fun <reified T> Any.isType(): Boolean { if (this is T) { return true } return false } fun main(args: Array<String>) { println("abc".isType<String>()) println(123.isType<String>()) } ``` 运行结果： ``` true false ``` 根据运行结果可知，**如果想把泛型参数类型变为实化类型，则这个泛型参数所在的函数必须是inline函数，而且泛型参数前必须用reified关键字来修饰**。 接下来我们看看使用实化类型参数的一些稍微有意义的例子。一个实化类型参数能发挥作用的最简单的例子就是标准库函数filterisinstance 。这个函数接收一个集合，选择其中那些指定类的实例，然后返回这些被选中的实例。下面展示了这个函数的用法。 ``` >>> val items = listOf("one", 2, "three") >>> println(items.filterIsInstance<String>()) [one, three] ``` 通过指定`<String>`作为函数的类型实参， 你表明感兴趣的只是字符串。因此函数的返回类型是`List<String>`。这种情况下，类型实参在运行时是已知的， 函数filterIsInstance 使用它来检查列表中的值是不是指定为该类型实参的类的 实例。 下面是Kotlin 标准库函数filterIsInstance 声明的简化版本。  #### 为什么实化只对内联函数有效？ 这是什么原理？为什么在inline 函数中允许这样写`element is T `，而普通的类或函数却不行？ 正如，编译器把实现内联函数的字节码插入每一次调用发生的地方。每次你调用带实化类型参数的函数时，编译器都知道这次特定调用中用作类型实参的确切类型。因此，编译器可以生成引用作为类型实参的具体类的字节码。实际上，对上面代码清单中的`filteris instance<String>`调用来说，生成的代码和下面这段代码是等价的： ``` for (element in this) { if (element is String){ //引用了具体类 destination.add(element) } } ``` 因为生成的字节码引用了具体类，而不是类型参数，它不会被运行时发生的类型参数擦除影响。 注意，带reified 类型参数的inline 函数不能在Java 代码中调用。普通的内联函数可以像常规函数那样在Java 中调用——它们可以被调用而不能被内联。带实化类型参数的函数需要额外的处理，来把类型实参的值替换到字节码中，所以它们必须永远是内联的。这样它们不可能用Java 那样普通的方式调用。 一个内联函数可以有多个实化类型参数，也可以同时拥有非实化类型参数和实化类型参数。注意， filterIsInstance 函数虽然被标记成川line ，而它并不期望lambda 作为实参。把函数标记成内联只有在一种情况下有性能优势，即函数拥有函数类型的形参并且其对应的实参一一lambda一一和函数一起被内联的时候。但现在这个例子中，并不是因为性能的原因才把函数标记成inline ，这里这样做是为了能够使用实化类型参数。 #### 使用实化类型参数代替类引用 另一种实化类型参数的常见使用场景是为接收`java.lang.Class` 类型参数的API 构建适配器。一个这种API 的例子是JDK 中的ServiceLoader ，它接收一个代表接口或抽象类的j ava.lang . Class ，并返回实现了该接口（或继承了该抽象类）的类的实例。现在我们看看如何利用实化类型参数更容易地调用这些API 。 通过下面的调用来使用标准的ServiceLoader Java API 加载一个服务： ``` val serviceImpl = ServiceLoader.load(Service::class.java) ``` `::class.java`的语法展现了如何获取j ava.lang.Class 对应的Kotlin 类。这和Java 中的Service.class 是完全等同的。 现在让我们用带实化类型参数的函数重写这个例子 ``` val serviceImpl = loadService<Service>() ``` 代码是不是短了不少？要加载的服务类现在被指定成了loadService 函数的类型实参。把一个类指定成类型实参要容易理解得多，因为它的代码比使用`::class.java`语法更短。 下面，我们看看这个loadService 函数是如何定义的：  这种用在普通类上的`::class.java`语法也可以同样用在实化类型参数上。使用这种语法会产生对应到指定为类型参数的类的`java.lang.Class`，你可以正常地使用它。 #### 实化类型参数的限制 尽管实化类型参数是方便的工具， 但它们也有一些限制。有一些是实化与生俱来的，而另外一些则是现有的实现决定的，而且可能在未来的Kotlin 版本中放松这些限制。 具体来说，可以按下面的方式使用实化类型参数： * 用在类型检查和类型转换中（ is、!is 、as 、as?) * 使用Kotlin 反射API ，我们将在后面讨论(::class) * 获取相应的`java.lang.Class` (`::class.java`) * 作为调用其他函数的类型实参 不能做下面这些事情： * 创建指定为类型参数的类的实例 * 调用类型参数类的伴生对象的方法 * 调用带实化类型参数函数的时候使用非实化类型形参作为类型实参 * 把类、属性或者非内联函数的类型参数标记成reified 最后一条限制会带来有趣的后果： 因为实化类型参数只能用在内联函数上，使用实化类型参数意味着函数和所有传给它的lambda 都会被内联。如果内联函数使用lambda 的方式导致lambda 不能被内联，或者你不想lambda 因为性能的关系被内联，可以使用noinline修饰符把它们标记成非内联的。