java 泛型擦除

红太狼 2022-10-29 11:17 251阅读 0赞

# 前言 #

本文讲从字节码层面深度学习泛型，这也是大厂常见面试

我们定义了如下类图所示类：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 1]

# 泛型的协变与逆变 #

定义  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 2]

## 泛型 extend的作用 ##

请先浏览如下代码

List<? extends Female> extenfemalesList1 = new ArrayList<Female>();
    //        List<? extends Female> extenfemalesList2 = new ArrayList<Human>();//error
    //        List<? extends Female> extenfemalesList3 = new ArrayList<Object>();//error
            List<? extends Female> extenfemalesList4 = new ArrayList<FemaleTeacher>();
            Female female = extenfemalesList1.get(0);
    //        extenfemalesList1.add(new Female()); //erro

`List<? extends Female>` 表示这个集合装载的`Female`之下的对象集合。也就是说这个集合可能是一个`new ArrayList<Female>()`,`new ArrayList<FemaleTeacher>()`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 3]

根据这个道理，我们取出来的数据一定`Female`对象或者其自类。  
因此以下代码顺利编译通过：

Female female = extenfemalesList1.get(0);

而如下代码必然出错,因为`List<? extends Female>`无法确定你的集合到底是`new ArrayList<Female>()`还是`new ArrayList<FemaleTeacher>()`，如果你是`new ArrayList<FemaleTeacher>()`那么放入必然引起错误，所以这里编译器无法判断因此抛出错误。

extenfemalesList1.add(new Female());

总结：泛型`extend`作用就是协变的概念，它用于表示其集合可能是继承泛型的子集合。

## 泛型 super的作用 ##

List<? super Female> extenfemalesList1 = new ArrayList<Female>();
            List<? super Female> extenfemalesList2 = new ArrayList<Human>();
            List<? super Female> extenfemalesList3 = new ArrayList<Object>();
    //        List<? super Female> extenfemalesList4 = new ArrayList<FemaleTeacher>();//erro
    //        Female female = extenfemalesList1.get(0);//erro
            extenfemalesList1.add(new Female()); 
            Object female = extenfemalesList1.get(0);

其概念图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 4]  
`List<? super Female>`表示这个集合可能是这个泛型的父亲的集合类型。

所以以下代码顺利编译

extenfemalesList1.add(new Female());//不过是哪个父集合类型都不违背语义
    Object female = extenfemalesList1.get(0);//不管父集合类型一定都满足是一个Object对象

违背语义报错代码

//取出来的可能是Object Female Human类型，所以无法确定Female类型
        Female female = extenfemalesList1.get(0);//erro

总结：泛型`super`作用就是逆变的概念

# 泛型擦除 #

何为泛型擦除？`JVM`运行会把泛型视为`Object`对象,这里特别注意这里针对的是`JVM`运行时。但是泛型信息依然保留在字节码层面，但是根据不同语法形式我们保存的位置不同。

## 泛型函数 ##

static  void test(List<FemaleTeacher> listParameter) {
        
            FemaleTeacher femaleTeacher = listParameter.get(0);
            System.out.println(femaleTeacher);
        }

请问如上代码是否可以在运行期拿到泛型的具体类型？  
泛型擦除体现在哪？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 5]

JVM调用指令说明：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 6]  
我们可以看到JVM最终的实现伪代码如下：

static  void test(List<Object> listParameter) {
        
            Object femaleTeacher = listParameter.get(0);
            FemaleTeacher femaleTeacher1 = (FemaleTeacher) femaleTeacher;
            System.out.println(femaleTeacher1);
    
        }

这便是泛型擦除。但是你仔细发现上图有一个`LocalVariableTypeTable`内部却显示了泛型  
![在这里插入图片描述][20210213020240131.png]

`LocalVariableTypeTable`存储于字节码方法区的`code`类型`attribute_info`的`attribute`中.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 7]

所以我们可以通过反射获取即可  
具体可以看网上的其他文章  
`https://www.cnblogs.com/wwjj4811/p/12592443.html`

泛型函数会比其他不含泛型的函数额外多一个`signature`类型的`attribute_info`属性存在`medhod_info`中  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 9]  
这里解释下`descriptor`和`signature`的区别：  
如果你在编写ASM框架的时候遇到这两个参数，如果你的字节码方法不含泛型`signature`直接写空字符串即可。

## 泛型类 ##

public class MyClassA<T> {
        
    
    
        public void say(T t) {
        
            System.out.println(t);
        }
    
      
    }
    
    public class MyClassB extends MyClassA<Human> {
        
    
    
    }

我们直接看`MyClassB`编译后信息：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 10]

泛型类会在字节码的`attribute_info`表多输一个`attriute_info`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 11]  
所以可以获取到类的泛型具体可参考如下链接

https://www.cnblogs.com/one777/p/7833789.html
    https://blog.csdn.net/u011082160/article/details/101025884

# type #

## 预备知识 ##

同过上文的分析,我们知道JVM会在运行时才体现泛型擦除机制,而泛型信息存在class中,为了拿到这些信息,`java1.5`推出了`Type`类型让我们通过反射拿取.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 12]

这里给出一个小结论或者小知识,如果你通过反射拿到的type类型为class,那么证明没有泛型信息.

一个小`Demo`希望对大家理解有帮助

interface GeneircInteface {
        }
    class MyTestClass implements GeneircInteface {
        }
    
    public class Java {
        
        public static void main(String[] args) {
        
        	//getGenericInterfaces获取接口上的泛型信息,如果没有实现接口返回的数组为0
        	//如果想得到继承类的泛型信息可以用getGenericSuperclass
            Type[] genericInterfaces = MyTestClass.class.getGenericInterfaces();
            boolean isClassType = genericInterfaces[0] instanceof Class;
            //ParameterizedType所代表的泛型信息后文在介绍,现阶段只需要知道它存储了泛型信息
            boolean isGenericType = genericInterfaces[0] instanceof ParameterizedType;
            //true
            System.out.println("isClass:" + isClassType);
            //false
            System.out.println("isGenericType:" + isGenericType);
        }
    }

上面的案例接口并没有泛型信息,我们添加一个小的泛型看看

interface GeneircInteface<T> {
        }
    class MyTestClass implements GeneircInteface<String> {
        }
    
    public class Java {
        
        public static void main(String[] args) {
        
            Type[] genericInterfaces = MyTestClass.class.getGenericInterfaces();
            boolean isClassType = genericInterfaces[0] instanceof Class;
            boolean isGenericType = genericInterfaces[0] instanceof ParameterizedType;
            //false
            System.out.println("isClass:" + isClassType);
            //true
            System.out.println("isGenericType:" + isGenericType);
        }
    }

## ParameterizedType ##

//ParameterizedType.java
    /**
     * 表示一个泛型声明类型:
     * 比如
     *    class MyTestClass {
     *   			class GeneircInteface<A,B> {
     *
     *   			}
     *    } 
     *  
     *  
     *  我们获取类class GeneircInteface<A,B>的ParameterizedType
     * 可通过ParameterizedType可以获得泛型所在的类GeneircInteface,对应getRawType函数
     * 可通过ParameterizedType泛型数组A,B被type表示的数组,对应getActualTypeArguments函数
     * 可通过ParameterizedType获取泛型类所在父类,这里返回MyTestClass 对应getOwnerType函数
     **/
    public interface ParameterizedType extends Type {
        
        /**
         * 返回所声明的泛型列表.
         * eg.
         * interface GeneircInteface<A,B> {}
         * 返回对应A和B的type数组
         */
        Type[] getActualTypeArguments();
    
        /**
         * 泛型所在的类 
         * 如interface GeneircInteface<A,B> {}
         * 返回 GeneircInteface.这里只能返回class类型的type
         */
        Type getRawType();
    
       	/**
       	* 返回泛型所在类的嵌套父类
       	*    class MyTestClass {
        *   			class GeneircInteface<A,B> {
        *
        *   			}
        *    } 
        *  我们获取类class GeneircInteface<A,B>的ParameterizedType
        *  getOwnerType返回MyTestClass .这里只能返回class类型的type
       	**/
        Type getOwnerType();
    }

案例:

package main;
    class MyTestClass {
        
       static class GeneircInteface<A,B> {
        
    
        }
    }

public class Java {
        
    
        public static void main(String[] args) throws NoSuchMethodException {
        
            Method method = new Java().getClass().getMethod("applyMethod", MyTestClass.GeneircInteface.class);
            Type[] types = method.getGenericParameterTypes();
            ParameterizedType pType = (ParameterizedType)types[0];
            //返回所有者类型，打印结果是
            //输出 class Main.MyTestClass
            System.out.println(pType.getOwnerType());
            //这里只能是Class类的Type哦,
            System.out.println(pType.getOwnerType() instanceof  Class);
    
    
            //因为泛型有两个,所以数组大小应该是2
            //返回的Type又是哪种这里不在铺开
            Type[] actualTypeArguments = pType.getActualTypeArguments();
    
            //输出2
            System.out.println(actualTypeArguments.length);
            
            //返回GeneircInteface的class,这里不在是ParameterizedType
            //Class 也是Type子类型哦
            //输出true
            System.out.println(pType.getRawType() instanceof  Class);
        }
        public static <T,C> void applyMethod(MyTestClass.GeneircInteface<T,C> list){
        }
        
    }

这个案例参考[ParameterizedType.getOwnerType() 函数怎么用?][ParameterizedType.getOwnerType_]

## GenericArrayType ##

数组类型的泛型`Type`.

//GenericArrayType.java
    /**
    * 表示一个数组存储的类型是包含泛型声明的类.
    * eg.
    *  class GeneircInteface<A,B> {}
    *  一个数组:
    *  GeneircInteface<String,String> [] arr;
    *  GenericArrayType所代表的就这个数组泛型信息
    **/
    public interface GenericArrayType extends Type {
        
     	//数组存储的泛型类的Type
     	//比如 GeneircInteface<String,String> [] arr;返回GeneircInteface的type
        Type getGenericComponentType();
    }

package main;
    class MyTestClass {
        
       static class GeneircInteface<A,B> {
        
    
        }
    }

public class Java {
        
    
        //声明泛型具体类型
        MyTestClass.GeneircInteface<Object, String>[] arr;
        //没有声明泛型具体类型
        MyTestClass.GeneircInteface[] arr2;
    
        List<Integer>[] arr3;
    
    
        public static void main(String[] args) throws NoSuchMethodException, NoSuchFieldException {
        
            Field arr = Java.class.getDeclaredField("arr");
            Field arr2 = Java.class.getDeclaredField("arr2");
            Field arr3 = Java.class.getDeclaredField("arr3");
    
            Type genericType = arr.getGenericType();
            Type genericType2 = arr2.getGenericType();
            Type genericType3 = arr3.getGenericType();
            //输出true
            System.out.println(genericType instanceof GenericArrayType);
            //输出false 这里主要提醒大家这个细节,如果没有声明泛型那么返回的type是class
            System.out.println(genericType2 instanceof GenericArrayType);
            //输出true
            System.out.println(genericType2 instanceof Class);
            //输出true
            System.out.println(genericType3 instanceof GenericArrayType);
    
            GenericArrayType genericTypeObj = (GenericArrayType) genericType;
            //这里返回
            Type genericComponentType = genericTypeObj.getGenericComponentType();
    
            //输出true ,上文讲过ParameterizedType这里就不在铺开
            //返回的是GeneircInteface的ParameterizedType
            System.out.println(genericComponentType instanceof ParameterizedType);
    
    
            GenericArrayType genericTypeObj3 = (GenericArrayType) genericType;
            //返回true,这里同上
            System.out.println(genericTypeObj3 instanceof ParameterizedType);
    
        }
        
    }

## TypeVariable ##

//表示一个类的原始泛型声明,这里必须区分ParameterizedType的区别
    //ParameterizedType用于获取已经明确泛型的类等,否则无法获取,比如interface MyInt< k extends String>就无法获取
    // TypeVariable 可以获取interface MyInt< k extends String>这里泛型信息,包括泛型的名字k和上界string
    public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement {
        
      
        // 返回泛型所定义的上界
      	// interface MyInt< k extends String>
      	// 返回的就是String.
      	// 为什么定义成数组?也许是向前兼容??
        Type[] getBounds();
    
        //定义泛型所在的类
        //interface MyInt< k extends String>
        //这里返回MyInt对应的class
        D getGenericDeclaration();
    	//返回泛型最原始定义的名字
    	//
    	// interface MyInt< k extends String>
    	// 这里就是返回 K
    	// 
        String getName();
    
      	//1.8多出的api,但是我没理解所以不讲解
        AnnotatedType[] getAnnotatedBounds();
    }

public static void main(String[] args) throws NoSuchMethodException, NoSuchFieldException {
        
    
            TypeVariable<Class<MyTestClass.GeneircInteface>>[] typeParameters = MyTestClass.GeneircInteface.class.getTypeParameters();
            //因为泛型有两个所以这里返回2
            System.out.println(typeParameters.length);
    
            TypeVariable<Class<MyTestClass.GeneircInteface>> typeParameter_0 = typeParameters[0];
    
            TypeVariable<Class<MyTestClass.GeneircInteface>> typeParameter_1 = typeParameters[1];
    
            //获得声明泛型的字母
            //输出k
            System.out.println(typeParameter_0.getName());
            //输出B
            System.out.println(typeParameter_1.getName());
    
            Type[] bounds = typeParameter_0.getBounds();
            //长度为1,我不理解为什么这里要返回数组类型,难不成可以定义多个上届
            System.out.println(bounds.length);
    
            Type bound = bounds[0];
            //输出上届class java.lang.String
            System.out.println(bound);
            //true
            System.out.println(bound instanceof  Class);
    
            //输出class java.lang.Class
            System.out.println(typeParameter_0.getGenericDeclaration());
    
        }

## WildcardType ##

//WildcardType.java
    //上文介绍的几个Type在大多数情况可以得到足够的泛型信息,但是少了一种就是泛型的上下界信息
    //定义上界:List<? extends String>
    //定义下界:List<? super String> listOne
    public interface WildcardType extends Type {
        
        //获取泛型的上界.如果没有设置那么就是Object,也就是说数组长度一定为1
        //为什么是数组类型,也许为了向前兼容
        Type[] getUpperBounds();
        //获取泛型的下界.如果没有设置那么就是长度为0的数组
        //为什么是数组类型,也许为了向前兼容
        Type[] getLowerBounds();
      
    }

public class Java {
        
    
    
        public static void main(String[] args) throws NoSuchMethodException, NoSuchFieldException {
        
    
            Method testFunction = Java.class.getDeclaredMethod("testFunction", List.class, List.class);
    
            //因为参数有两个所以这里数组长度为2
            Type[] genericParameterTypes = testFunction.getGenericParameterTypes();
            //输出2
            System.out.println(genericParameterTypes.length);
    
            //因为参数包含所以必然是一个ParameterizedType
            ParameterizedType genericParameterType = (ParameterizedType) genericParameterTypes[0];
            //通过ParameterizedType的getActualTypeArguments返回具体泛型信息
            Type[] actualTypeArguments = genericParameterType.getActualTypeArguments();
            //因为这里只有一个泛型<? super String> 所以只数组长度1
            //输出1
            System.out.println(actualTypeArguments.length);
    
            //<? super String> 包含通配符所以type必然是WildcardType
            WildcardType actualTypeArgument = (WildcardType) actualTypeArguments[0];
            //输出? super java.lang.String
            System.out.println(actualTypeArgument);
            //<? super String>声明了一个下界,所以lowerBounds不为空,长度为1
            //为什么是数组而不是直接一个Type我也没确定,也许是向前兼容
            Type[] lowerBounds = actualTypeArgument.getLowerBounds();
            //输出1
            System.out.println(lowerBounds.length);
    
            //下界是String且不不包含泛型信息,可以输出Type为class
            Type lowerBound = lowerBounds[0];
            //输出
            System.out.println(lowerBound instanceof Class);
    
            //获取上届信息,没有声明默认就是Object
            Type[] upperBounds = actualTypeArgument.getUpperBounds();
            //输出1
            System.out.println(upperBounds.length);
            //输出 class java.lang.Object
            System.out.println(upperBounds[0]);
            //输出 true
            System.out.println(upperBounds[0] instanceof Class);
    
            //关于的例子 List<? extends String> listTwo
            ParameterizedType genericParameterTypeTwo = (ParameterizedType) genericParameterTypes[1];
            Type[] actualTypeArgumentsTwo = genericParameterTypeTwo.getActualTypeArguments();
    
            WildcardType wildcardTypeTwo = (WildcardType) actualTypeArgumentsTwo[0];
    
            //注意List<? extends String>定义了上届,但是下界没有定义所以这里输出0
            //输出 0
            System.out.println(wildcardTypeTwo.getLowerBounds().length);
            //定义了上界所以这里长度为1
            //输出1
            System.out.println(wildcardTypeTwo.getUpperBounds().length);
        }
    
    
        void testFunction(List<? super String> listOne, List<? extends String> listTwo) {
        
    
        }
    
    
    }

# 参考 #

[Java中的Type][Java_Type]  
[Java中的Type类型详解][Java_Type 1]  
[ParameterizedType.getOwnerType() 函数怎么用?][ParameterizedType.getOwnerType_]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]: /images/20221024/0569cffe7862469e88f1b71ccf39dda0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 1]: /images/20221024/a57632f51ddf439595aa773d0509024b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 2]: /images/20221024/2e6f201a56a74ad8a9de289c73cfd38f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 3]: /images/20221024/e13074d2c2794417934e39a33fb4abb0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 4]: /images/20221024/2b55ed8aed164a4391479f8b2ff61579.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 5]: /images/20221024/08f73a27c86242579f2bddfc033c56f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 6]: /images/20221024/e0a922e676254b79824bf00e142a2d2e.png
[20210213020240131.png]: /images/20221024/9de2e6f2c8754f7baab51d43a3fdc13b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 7]: /images/20221024/fe45543fbaff4d9194de0c64537435d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 8]: /images/20221024/2c06f3081d8347b79fa92bf396cf2aeb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 9]: /images/20221024/63d40fb2f64045debcde8751cab915f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 10]: /images/20221024/9491ab0781d048e7a213bafe4a0d43f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 11]: /images/20221024/fe9c6eb10b6a47eeb081942241efb492.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70 12]: /images/20221024/dfbe3b9a2478413f8882553203ba207d.png
[ParameterizedType.getOwnerType_]: https://segmentfault.com/q/1010000000655631
[Java_Type]: https://www.cnblogs.com/linghu-java/p/8067886.html
[Java_Type 1]: https://juejin.cn/post/6844903597977632776