Java进阶之深入理解泛型的实现机制

电玩女神 2022-12-23 07:13 31阅读 0赞

## 1 Java泛型的实现机制是怎样的? ##

答：1.为什么要使用泛型程序设计？**泛型就是类型参数化，处理的数据类型不是固定的，而是可以作为参数传入。意味着编写的代码可以对多种不同的类型的对象重用**。类型参数的**好处有：(1)调用get()的时候，我们不需要进行强制类型转换；(2)编译器会检查插入类型，防止插入错误类型的对象；(3)让程序更易读，也更安全**。

2.Java采用类型擦除，这里我通过三个点来说明哈：什么是类型擦除、类型擦除有什么好处、类型擦除存在什么问题？  
(1)举例说什么是类型擦除？class Node \{ T getNode() \{ return node;\} \}：因为T是一个无限定的变量，所以直接用Object替代；可以包含不同类型的Node，例如:Node< String >、Node< Double >，但是它们在擦除类型后，都会变成原始的Node。  
(2)类型擦除有什么好处呢？①**减小运行时内存的负担**。例如：存在类似List< Integer >，List< Double >等这样的类型，真正被加载进方法区存储的只有List类型，类型擦除后减少了内存的负担。②**向前兼容性好**。Java在**1.5版本才推出泛型**这个概念，当时Java语言的用户群已经是一个相当庞大的数量了，所向前兼容也是当时Java开发者着重考虑的一个点。  
(3)类型擦除存在什么问题？**①基本类型无法作为泛型实参**：在使用过程中就意味着会有装箱和拆箱的开销：为此，谷歌也推出了SpareArray的数据结构来提高执行效率。**②泛型类型无法用作方法重载**，因为类型擦除意味着List< Integer >和List< String>编译后其类型都是List，也就是属于同个方法。**③泛型类型无法当做真实类型使用**，由于类型擦除后像new T()这样的类型是不存在的，所以也就无法直接当成真实类型使用。这也是为什么Gson.fromJson需要传入Class？因为返回值T被类型擦除成Object，在定义时不知道返回什么具体对象，所以需要传入Class。**④静态方法无法引用类泛型参数**：类的泛型参数只有在类实例化的时候才知道，而静态方法的执行不需要有类的示例存在，所以静态方法无法引用类泛型参数。**⑤泛型类型会带来类型强转的运行时开销**。

3.针对类型擦除存在的问题，补救方案是“类型通配符和边界”。  
(1)先说**PECS规则**，分为：**①上界通配符<? extends T>，频繁往外读取数据：Producer = output = out（协变）；和②下界通配符< ? super T>，频繁往里面插入数据：Comsumer = input = in（型变）**。  
(2)然后上下界通配符存在副作用。  
**当存入时：依赖泛型类型，可知类型子类可存：**  
①? extends / out Fruit：虽然知道最大类型是Frult，但具体什么类型不知道，所以不可存；  
②? super / in Fruit：知道了类型一定是Fruit的自己或父类，所以只要是Fruit的子类都可存入；  
**当获取时：依赖承接类型，可知类型的最大类型作为承接者**：  
①? extends / out Fruit：虽然知道最大类型是Frult，所以可用Fruit或父类Food来承接获取；  
②? super / in Fruit：不知道最大类型是什么，只能选万物基类Object来承接，也快丢掉所有数据了，不适合读取；

4.类型擦除后怎么获取泛型参数？  
(1)为什么可以获取泛型参数？**泛型类型虽然被擦除了，但是被擦除的类型信息还是会以某种形式存储下来，并支持在运行时获取。这种形式就是指元素附加的签名信息（Signatures），查看字节码时可以看到泛型对应的Signatures标记**；  
(2)**可以通过getGenericReturnType()等反射获取方法元素泛型**；  
(3)Gson是如何通过借助TypeToken获取泛型参数的类型的方法？**Gson构建泛型Type，实际上调用的就是getGenericReturnTypes方法**。获得了匿名内部类的Class类型genericType，但是并没有直接将泛型参数T的Class类型传进来，那又是如何获得泛型参数的类型的呢？通过匿名内部类型genericType，可以访问到它父类TypeToken的构造方法，再获取Class字节码中保存的泛型签名信息，即可获取类型List< Integer >等。

![在这里插入图片描述][20201125072138300.png_pic_center]

### 1.1 这道题想考察什么? ###

答：（1）考察要点  
●对Java泛型使用是否仅停留在集合框架的使用(初级)  
●对Java泛型的实现机制的认知和理解、是否有足够的项目开发实战和“踩坑”经验(中级)  
●对泛型(或模板)编程是否有深入的对比研究、对常见的框架原理是否有过深入剖析(高级)

（2）题目剖析  
●题目区分度非常大  
●回答需要提及以下几点才能显得有亮点:①类型擦除从编译角度的细节；②类型擦除对运行时的影响；③类型擦除对反射的影响；④对比类型不擦除的语言；⑤为什么Java选择类型擦除；  
●可从类型擦除的优劣来着手分析回答。

## 2 为什么要使用泛型程序设计？ ##

答：**泛型就是类型参数化，处理的数据类型不是固定的，而是可以作为参数传入。意味着编写的代码可以对多种不同的类型的对象重用**。类型参数的**好处有：(1)调用get()的时候，我们不需要进行强制类型转换；(2)编译器会检查插入类型，防止插入错误类型的对象；(3)让程序更易读，也更安全**。如下面的例子：

ArrayList files = new ArrayList<String>();
    String fileName = files.get(0);  // (1)
    files.add(new File("")); // 只能插入String，如果插入File()，提示：编译错误 (2)

// 定义一个接口
    interface Money<T> {
        
       T get(intindex);
       boolean add(T e);
    }
    // 定义一个类
    public class Apple<T>{
        
       private T info;
       public Apple(T info) {
        
         this.info = info;
       }

## 3 什么是类型擦除？ ##

答：**虚拟机没有泛型类型对象——所有对象都属于普通类**。无论何时定义一个泛型类型，都会自动提供一个相应的原始类型（raw type）。**这个原始类型的名字就是去掉类型参数后的泛型类型名，类型变量会被擦除，并替换为其限定类型（或者对于无限定的变量则替换为Object）**。

### 3.1 如何验证类型擦除？ ###

答：**因为T是一个无限定的变量，所以直接用Object替代**；**Pair pair = getNode()会将返回的Object类型强制转换为Pair类型**；**可以包含不同类型的Node，例如:Node< String >、Node< Double >，但是它们在擦除类型后，都会变成原始的Node**。

（1）类型擦除前

class Node<T> {
        
            T node;
            
            public Node() {
        
                this.node = null;
            }
            public T getNode() {
        
                return node;
            }
        }

（2）类型擦除后

class Node {
        
            Object node;
    
            public Node() {
        
                this.node = null;
            }
            public Object getNode() {
        
                return node;
            }
        }

（3）选取getNode()方法的字节码分析

//    @groovyx.ast.bytecode.Bytecode
    //    public Object getNode() {
        
    //        aload 0
    //        getfield com.read.kotlinlib.generic.GenericClass$Node.node >> Object
    //        areturn
    //    }
    
    //    // access flags 0x1
    //    // signature ()TT;
    //    // declaration: T getNode()
    //    public getNode()Ljava/lang/Object;
    //     L0
    //      LINENUMBER 35 L0
    //      ALOAD 0
    //      GETFIELD com/read/kotlinlib/generic/GenericClass$Node.node : Ljava/lang/Object;
    //      ARETURN
    //     L1
    //      LOCALVARIABLE this Lcom/read/kotlinlib/generic/GenericClass$Node; L0 L1 0
    //      // signature Lcom/read/kotlinlib/generic/GenericClass<TT;>.Node<TT;>;
    //      // declaration: com.read.kotlinlib.generic.GenericClass<T>.Node<T>
    //      MAXSTACK = 1
    //      MAXLOCALS = 1

## 4 类型擦除有什么好处？ ##

答：（1）**减小运行时内存的负担**。例如：存在类似List< Integer >，List< Double >等这样的类型，真正被加载进方法区存储的只有List类型，类型擦除后减少了内存的负担。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center]  
（2）**向前兼容性好**。Java在**1.5版本才推出泛型**这个概念，当时Java语言的用户群已经是一个相当庞大的数量了，所以**向前兼容也是当时Java开发者着重考虑的一个点**。**不管在前泛型时代还是泛型时代，以下的写法都是被允许的，它们的泛型元素都是Raw类型**：

List list;
     ArrayList array;

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 1]

## 5 类型擦除存在什么问题？ ##

答：  
**（1）基本类型无法作为泛型实参**  
![在这里插入图片描述][20201123233106475.png_pic_center]  
**在使用过程中就意味着会有装箱和拆箱的开销**：为此，谷歌也**推出了SpareArray的数据结构来提高执行效率**，如使用SparseIntArray用来取代Integer做为key类型的时候用HashMap<Integer, Integer>的场景，它内部就有一个整型数组，不需要装箱拆箱。SparseBooleanArray来取代HashMap<Integer, Boolean>等等。

private int[] mKeys;    
    private Object[] mValues;

[Android内存优化（使用SparseArray和ArrayMap代替HashMap）][Android_SparseArray_ArrayMap_HashMap]

（2）**泛型类型无法用作方法重载**  
**类型擦除意味着List< Integer >和List< String>编译后其类型都是List，也就是属于同个方法**：

![在这里插入图片描述][20201123233755171.png_pic_center]  
（3）**泛型类型无法当做真实类型使用**  
**由于类型擦除后像new T()这样的类型是不存在的，所以也就无法直接当成真实类型使用**：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 2]  
这也是**为什么Gson.fromJson需要传入Class类型？**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 3]

答：**因为返回值T被类型擦除成Object，在定义时不知道返回什么具体对象，所以需要传入Class**。后面说到通过字节码里面附加的签名信息拿到返回对象具体类型。为什么有不同的方法？因为反射得解析签名信息，而且只有在调用的时候才有这个信息，而fromJson在定义的时候是没有这个信息的。

（4）**静态方法无法引用类泛型参数**  
**类的泛型参数只有在类实例化的时候才知道，而静态方法的执行不需要有类的示例存在，所以静态方法无法引用类泛型参数**。但是，静态方法可以自己定义泛型类型，然后引用泛型参数。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 4]

（5）**泛型类型会带来类型强转的运行时开销**

List<String> strList = new ArrayList<String>();
    String value = strList.get(0);

**实际字节码指令执行strList.get()方法时，经过类型擦除后，还是需要做类型强转：**

// INVOKEINTERFACE java/util/List.get (I)Ljava/lang/Object;
    // CHECKCAST java/lang/String

在1.5以下版本，需要额外强转；在1.5+版本，不需要额外强转，但是ArrayList内部本质会进行强转：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 5]

## 6 类型擦除的补救方案“类型通配符和边界”的原理？ ##

答：<? extends T >和< ? super T >是Java泛型中的“通配符（Wildcards）”和“边界（Bounds）”的概念：  
**< ? extends T >：是指 “上界通配符（Upper Bounds Wildcards）”；< ? super T >：是指 “下界通配符（Lower Bounds Wildcards）”**。

### 6.1 为什么要用通配符和边界？ ###

答：我们有Fruit类，和它的派生类Apple类：

internal open inner class Fruit
    internal open inner class Apple : Fruit()

还有一个最简单的容器：Plate类，盘子里可以放一个泛型的“东西”。我们对这个东西做最简单的“放”和“取”的动作：set()和get()方法

internal class Plate<T>(private var item: T) {
        
            fun set(t: T) {
        
                item = t
            }
    
            fun get(): T {
        
                return item
            }
        }

定义一个“水果盘子”，逻辑上水果盘子当然可以装苹果。但实际上Java编译器不允许这个操作，会报错，**“装苹果的盘子”无法转换成“装水果的盘子”**。  
![在这里插入图片描述][20201124083156120.png_pic_center]  
所以，就算**容器里装的东西之间有继承关系，但容器之间是没有继承关系的**。为了让泛型用起来更舒服，**Sun的大佬就想出了<? extends T>和<? super T>的办法，来让”水果盘子“和”苹果盘子“之间发生关系**。

### 6.2 什么是 上界 通配符（<? extends T>）？对应Kotlin的 协变？ ###

答：

// Java
    Plate<? extends Fruit>

// kotlin 
    Plate<out Fruit>

翻译成人话就是：**一个能放水果以及一切是水果派生(子)类的盘子**。再直白点就是：**啥水果都能放的盘子**。Plate<? extends Fruit>和Plate< Apple>最大的区别就是：Plate<? extends Fruit>是Plate< Fruit>以及Plate< Apple>的基类。直接的好处就是，可以**用“苹果盘子”给“水果盘子”赋值了**。

val p1: Plate<out Fruit> = Plate<Fruit>(Apple())
    val p2: Plate<out Fruit> = Plate<Apple>(RedApple())

把Fruit和Apple的例子再扩展一下，食物分成水果和肉类，水果有苹果和香蕉，肉类有猪肉和牛肉，苹果还有两种青苹果和红苹果

// Lev 1
    internal open inner class Food
    // Lev 2
    internal open inner class Fruit : Food()
    internal open inner class Meat : Food()
    // Lev 3
    internal open inner class Apple : Fruit()
    internal inner class Banana : Fruit()
    internal inner class Pork : Meat()
    internal inner class Beef : Meat()
    // Lev 4
    internal inner class RedApple : Apple()
    internal inner class GreenApple : Apple()

在这个体系中，下界通配符 Plate<? extends Fruit> 覆盖下图中蓝色的区域。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 6]

### 6.3 什么是 下界 通配符（<? super T>）？对应Kotlin的 逆变？ ###

答：

// Java 
    Plate<? super Fruit>

// Kotlin 
    Plate<in Fruit>

表达的就是**相反的概念：一个能放水果以及一切水果父类的盘子**。Plate<? super Fruit>是Plate< Fruit>的基类，但不是Plate< Apple>的基类。对应刚才那个例子，Plate<? super Fruit>覆盖下图中红色的区域。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 7]

### 6.4 怎么容易记忆 PECS(Producer Extends Consumer Super) + (in & out )？ ###

答：（1）**上界通配符<? extends T><? extends T>，频繁往外读取数据：Producer = output = out（协变）**；  
（2）**下界通配符<? extends T>< ? super T>，频繁往里面插入数据：Comsumer = input = in（型变）**。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 8]  
[Kotlin 泛型中的 in 和 out 怎么记？][Kotlin _ in _ out]

### 6.5 上下界通配符的副作用？ ###

答：1、**存入：依赖泛型类型，可知类型子类可存：**  
（1）**? extends / out Fruit：虽然知道最大类型是Frult，但具体什么类型不知道，所以不可存；**  
（2）**? super / in Fruit：知道了类型一定是Fruit的自己或父类，所以只要是Fruit的子类都可存入；**

2、**获取：依赖承接类型，可知类型的最大类型作为承接者：**  
（1）**? extends / out Fruit：虽然知道最大类型是Frult，所以可用Fruit或父类Food来承接获取；**  
（2）**? super / in Fruit：不知道最大类型是什么，只能选万物基类Object来承接，也快丢掉所有数据了，不适合读取；**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 10]

### 6.6 无限定通配符<?>，没有约束 ###

答：通配符<?>和类型参数的区别就在于，**对编译器来说所有的T都代表同一种类型**。比如下面这个泛型方法里，三个T都指代同一个类型，要么都是String，要么都是Integer。

public <T> List<T> gsonToList(T str)

但**通配符<?>没有这种约束，Plate<?>单纯的就表示：盘子里放了一个东西，是什么我不知道**。

### 6.7 学习链接？ ###

[Java泛型中extends和super的区别？][Java_extends_super]

[面试官问我：“泛型擦除是什么，会带来什么问题？”][Link 1]

[几个搞不太懂的术语：逆变、协变、不变][Link 2]

[Java泛型中的PECS原则][Java_PECS]

《Java核心技术 I》第八章、《Java编程的逻辑-第八章》

## 7 类型擦除后怎么获取泛型参数？ ##

答：

### 7.1 什么是方法签名？ ###

答：**在虚拟机中，内部类型签名在字节码层面用来识别函数或者类**。在Java中，**函数签名包括：函数名，参数的数量、类型和顺序**；**返回值和函数上声明的异常并不属于函数签名的构成部分**。

List<String> list  // Ljava/util/List<Ljava/lang/String;>;

// 字节码：com.read.kotlinlib.generic/Main/main:(Ljava/lang/String;Ljava/lang/Integer;)Ljava/lang/String;
    // 方法签名：com.read.kotlinlib.generic/Main/main:(Ljava/lang/String;Ljava/lang/Integer;)
    fun main(a: String?, b: Int?) : String {
        
    	return ""
    }

（1）下两个函数签名不同：因为他们虽然函数名相同，但是参数类型不同

doSomething(String[] y);
    doSomething(String y);

（2）下面三个函数的签名相同：因为他们的函数名相同，参数数量，类型和顺序也一致。

int doSomething(int y) 
    String doSomething(int x)
    int doSomething(int z) throws java.lang.Exception

[Java中的方法签名解读][Java]

### 7.2 类型擦除后怎么获取泛型参数？ ###

答：在Java中，**泛型类型虽然被擦除了，但是被擦除的类型信息还是会以某种形式存储下来，并支持在运行时获取。这种形式就是指元素附加的签名信息（Signatures）**，谷歌是这么定义Signatures：

签名对使用Java编程语言编写的声明进行编码，这些声明使用Java虚拟机的类型系统之外的类型。 它们仅支持类文件的反射和调试以及编译。

获取Signatures的方法如下：

public abstract class GenericClass<T> {
        
        Class<T> type;
        public GenericClass() {
        
            this.type = (Class<T>) getClass();
        }
        public List<Map<T, T>> getValue() {
        
            return null;
        }
    }

private void getGenericsArguments() {
        
    	// 匿名内部类
        GenericClass<String> genericClass = new GenericClass<String>() {
        
        	@Override
            public List<Map<String, String>> getValue() {
         return null;}
        };
    
        // 获取类元素泛型
        ParameterizedType superType =
        		(ParameterizedType) genericClass.getClass().getGenericSuperclass();
        for (Type actualTypeArgument : superType.getActualTypeArguments()) {
        
        	System.out.println("Superclass + actualTypeArgument: " + actualTypeArgument);
             // Superclass + actualTypeArgument: class java.lang.String
        }
    
        // 获取方法元素泛型
        ParameterizedType methodType =
        		(ParameterizedType) genericClass.getClass().getMethod("getValue").getGenericReturnType();
        for (Type actualTypeArgument : methodType.getActualTypeArguments()) {
        
        	System.out.println("Method + actualTypeArgument: " + actualTypeArgument);
            // Method + actualTypeArgument: java.util.Map<java.lang.String, java.lang.String>
        }
    }

所以，在混淆时需要保留签名信息：

-keepattributes Signature

### 7.3 如何保存 泛型类型签名信息？ ###

答：（1）对比List是否加泛型  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 11]  
[通用类型存储在Java类文件中的什么位置？][Java 1]

（2）通过ASM查看的字节码是如何保存 泛型类型签名信息的

private void genericErasure() {
        
        List<String> list = new ArrayList<String>();  // Ljava/util/List<Ljava/lang/String;> ;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 12]

### 7.4 Gson是如何通过借助TypeToken获取泛型参数的类型的方法？ ###

答：Gson构建泛型Type，实际上调用的就是getGenericReturnTypes方法。**获得了匿名内部类的Class类型genericType，但是并没有直接将泛型参数T的Class类型传进来，那又是如何获得泛型参数的类型的呢？通过匿名内部类型genericType，可以访问到它父类TypeToken的构造方法，再获取Class字节码中保存的泛型签名信息，即可获取类型List< Integer >等**。

Type genericType = new TypeToken<List<Integer>>(){
         }.getType();  // 匿名内部类

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 13]

public class TypeToken<T> {
        
      final Class<? super T> rawType;
      final Type type;
      final int hashCode;
    
      protected TypeToken() {
        
        this.type = getSuperclassTypeParameter(getClass());
        this.rawType = (Class<? super T>) $Gson$Types.getRawType(type);
        this.hashCode = type.hashCode();
      }
      
      static Type getSuperclassTypeParameter(Class<?> subclass) {
        
          Type superclass = subclass.getGenericSuperclass();
          if (superclass instanceof Class) {
        
              throw new RuntimeException("Missing type parameter.");
          }
          ParameterizedType parameterized = (ParameterizedType) superclass;
          return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);
      }
      
      public final Type getType() {
        
          return type;
      }
    }

[Android:Gson通过借助TypeToken获取泛型参数的类型的方法][Android_Gson_TypeToken]

[Gson解析泛型对象时TypeToken的使用方法][Gson_TypeToken]

#### 7.4.1 Retrofit是如何使用泛型签名的？ ####

答：  
![在这里插入图片描述][20201125072019548.png_pic_center]

## 8 Kotlin反射的实现原理？ ##

答：（1）**Kotlin每个类编译完后，都会有注解Metadata，保存了类的很多信息**。可以通过反射获取当前类的信息，如：名字，都是从注解中获取。所以，**如果使用kotlin的反射，需要添加混淆-keep class kotlin.Metadata\{\*;\}避免注解被混淆了**。  
（2）**Kotlin的特性比Java多很多，而它又是运行在Java虚拟机上的。如果Kotlin通过反射需要获取那么多的特性，而这时候Java虚拟机不知道这些新特性**。那是**虚拟机怎么做到的？Kotlin是通过注解来实现的，注解叫metadata，注解在每个类上**。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 14]

[Java高级面试 —— Java的泛型实现机制是怎么样的？][Java_ _ Java]

## 9 如何继承泛型 ##

### 9.1 泛型<M, T> ###

public class ServiceImpl<M, T> {
        
        public void test(M, T) {
        
            // do something
        }
    }

子类继承父类分两种情况：

// 1、保持子类的泛型化
    public TestServiceImpl<M, T> extends ServiceImpl<M, T> {
        
        @Override
        public void test(M, T) {
        
        }
    }

// 2、子类不再泛型化
    public TestServiceImpl extends ServiceImpl<String, Integer> {
        
        @Override
        public void test(String, Integer) {
        
        }
    }

### 9.2 泛型< V extends IMvpBaseView> ###

public abstract class AbstractMvpPresenter<V extends IMvpBaseView> {
        
    }

子类继承父类分两种情况：

// 1、保持子类的泛型化
    public class BaseLoadMorePresenter<IV extends ILoadMoreView> extends AbstractMvpPresenter<IV> {
         
    }
    
    public class RequestPresenter extends BaseLoadMorePresenter<RequestView> {
        
    }

// 2、子类不再泛型化
    public class BaseLoadMorePresenter extends AbstractMvpPresenter<ILoadMoreView> {
         	
    }

[20201125072138300.png_pic_center]: /images/20221120/dac86aa0e11d474690aa0d722ba8d892.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/3f7cd1607bea4d67b1c4d2d739e35e25.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/cdccb858bc3544ccb2c30fd3e83b6d88.png
[20201123233106475.png_pic_center]: /images/20221120/d8a4560b7cbb48b48661909db2587612.png
[Android_SparseArray_ArrayMap_HashMap]: https://blog.csdn.net/u010687392/article/details/47809295
[20201123233755171.png_pic_center]: /images/20221120/79f2df2511824304ba2f6aa383019324.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/2e43dacd22fe4411bd0e0fb5d3a71cb6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/2f35970c32bf4b55a2f77468a125c6aa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/aa9a385a256e4a82af024db8adbb3dd3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/332969a830dd43cd96db8105adb7429b.png
[20201124083156120.png_pic_center]: /images/20221120/e77fb17525b544a9bfea9f0ff1660e31.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/004de4de69b746ca94ede26a686e6bf7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221120/f8279f75b82e4dff8853f9f777d92047.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221120/e8bd7f62aab9419db68493e5c104ed34.png
[Kotlin _ in _ out]: https://zhuanlan.zhihu.com/p/32583310
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221120/16c5ef85290b4a9291ef0c856eae5e7e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221120/7d199ae71ee74144b7860094430b9054.png
[Java_extends_super]: https://blog.csdn.net/qq_36898043/article/details/79655309
[Link 1]: https://juejin.cn/post/6844904083199918093
[Link 2]: https://juejin.cn/post/6844904118943744008
[Java_PECS]: http://blog.csdn.net/xx326664162/article/details/52175283
[Java]: https://blog.csdn.net/w605283073/article/details/90181912
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221120/6c449aa572f24565bd3e2697a0264834.png
[Java 1]: https://stackoverflow.com/questions/937933/where-are-generic-types-stored-in-java-class-files
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221120/3a2f8cc35663486d956a837b60564a7c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221120/46f0c476f4df428d9fa08b48db8e5a5f.png
[Android_Gson_TypeToken]: https://blog.csdn.net/zzp_403184692/article/details/8266575
[Gson_TypeToken]: https://www.jianshu.com/p/cdea9a8db18b
[20201125072019548.png_pic_center]: /images/20221120/dd90d13e517a4a7b858785248f7f481f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4_size_16_color_FFFFFF_t_70_pic_center 14]: https://img-blog.csdnimg.cn/20201124230702243.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5saWd1YW4=,size_16,color_FFFFFF,t_70#pic_center
[Java_ _ Java]: https://blog.csdn.net/u014756589/article/details/100813171