--- theme: orange highlight: darcula --- ## 泛型的定义 ### 泛型类的定义下面定义了一个泛型类 `Pair`，它有一个泛型参数 `T`。 ```java public class Pair { private T start; private T end; } ``` 实际使用的时候就可以给这个 `T` 指定任何实际的类型，比如下面所示，就指定了实际类型为 `LocalDate`，泛型给了我们一个错觉就是通过个这个模板类 `Pair`，我们可以在实际使用的时候动态的派生出各种实际的类型，比如这里的 `Pair` 类。 ```java Pair period = new Pair<>(); ``` ### 泛型类的继承 **子类是一个泛型类**的定义方法如下： ```java public class Interval extend Pair {} ``` 这里的 `Interval` 类是一个泛型类，也可以像上面使用 `Pair` 类一样给它指定实际的类型。 **子类是一个具体类**的定义方法如下： ```java public class DateInterval extends Pair {} ``` 这里的 `DateInterval` 类就是一个具体的类，而不再是一个泛型类了。这里的语义是 `DateInteral` 类继承了 `Pair` 类，这里的 `Pair` 类也是一个具体类。但是由于 Java 的泛型实现机制，这里会带来多态上的一个问题，见下面的分析。而像下面的这种定义具体类的写法是错误的： ```java public class DateInterval extends Pair {} ``` ### 泛型方法的定义泛型方法定义时，类型变量放在修饰符的后面，返回值的前面。泛型方法既可以泛型类中定义，在普通类中定义。 ```java public static T genericMethod(T a) {} ``` 这里顺便记录一下，因为是使用擦除来实现的泛型，因此字节码中的方法的签名是不会包含泛型信息的。对于泛型方法会多生成一个 Signature 的属性，用于记录方法带泛型信息的签名，反编译器也可以根据这个信息将泛型方法还原回来。 ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/96348bbdef454e09bbd787f5f36bf72d~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=hGHmuLNQjAMEckdmvg2ezqNVZVQ%3D) ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/0e8b4ed2963b4394be1469d33c8469f7~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=t1ZHsruWIZDBM8eA506ZKOHK6ps%3D) ### 构造函数泛型下面的代码定义了一个泛型类 `ConstructorGeneric`，它的泛型参数是 `T`，这个类的构造函数也是泛型的，它有一个泛型参数 `X`。 ```java class ConstructorGeneric { public ConstructorGeneric(X a) {} } ``` 创建该对象的代码如下： ```java ConstructorGeneric t = new ConstructorGeneric("123"); ``` 这里 `new` 后面的 `String` 是传给构造器的泛型 `X` 的，即 `X` 的实际类型为 `String`；类的范型参数是由 `Number` 传递的，即 `T` 的实际类型是 `Number`。这里两个都是省略，写在这里是为了显示区分出两个参数传递的位置。 ### 类型变量的限定 **带单个上界限定**：下面的代码定义了一个 `NatualNumber` 类，它的泛型参数 `T` 限制为 `Integer` 或者 `Integer` 的子类。 ```java public class NaturalNumber { private T n; public NaturalNumber(T n) { this.n = n; } public boolean isEven() { return n.intValue() % 2 == 0; } } ``` 调用代码如下： ```java // 正常 NaturalNumber natural1 = new NaturalNumber<>(1); // 无法编译，因为这里和泛型类定义的上界不符合 NaturalNumber natualral2 = new NaturalNumber<>(1.0); ``` **带多个上界的限定**：多个上界之间使用 `&` 符号进行分隔，如果多个限定中有类，则类需要排在接口后面（因为 Java 不支持多继承，所以不存在有多个限定的类的情况）。使用时需要满足所有的限定条件才能执行，**这个校验应该是在编译时期做的**，因为擦除之后，只会保留第一个限定界。 ```java class A {} interface B {} class C extends A implements B {} public static void test(T a) {} public static void main(String[] args) { // 编译错误，A 只能满足一个上界 test(new A()); // 正常 test(new C()); } ``` ## 通配符在泛型中使用 `?` 表示通配符，它的语义是表示未知的类型。通配符可以用作方法的形参、字段的定义、局部变量的定义，以及有的时候作为函数的返回值。通配符不能作为实参调用泛型方法，不能创建对象，或者派生子类型。 ### 上界通配符当你想定义一个普通方法，这个普通方法可以处理某一类的 List 中的元素时，比如像：`List`，`List`，`List` 时，这个时候如果你把方法的入参定义为 `List` 是不行的，因为在 Java 中 `List` 不是 `List` 的子类。 ```java public static void process(List numbers) {} // 编译错误 List numbers = new ArrayList<>(); proess(numbers); ``` 假设 List\ 是 List\ 的子类，则可以实现如下的代码： ```java List integers = new ArrayList<>(); // 假设下面是成立的 List numbers = integers; // 下面这句也应该是合法的，但是这违背了 intergers 只能存放 Integer 的语义 numbers.add(new Double()); ``` 从上面的例子可以看出，如果允许 `List` 是 `List` 的子类型，则会破坏泛型的语义，因此这在 Java 中是不允许的。但是又实际存在上面描述的这种需求，因此 Java 提供了上界通配符的语法，则方法定义可以定义为如下： ```java public static void process(List numbers) { for (Number num : numbers) { // do something } } // 下面的调用都是能够正常编译通过的 List numbers = new ArrayList<>(); process(numbers); List integers = new ArrayList<>(); process(integers); List doubles = new ArrayList<>(); process(doubles); ``` 这里的 `? extends Number` 的语义就是可以匹配 `Number` 或者 `Number` 子类的 `List`，需要注意的是在 Java 中的继承（`extends`）和实现（`implements`）在这里都用关键字 `extends` 来表示。从这里也可以看出，`List\` 的返回值是可以赋值给 `Number` 类型的。这里可以想象一下 `List` 的 `get()` 方法的泛型参数 `E` 就变成了` ? extends Number` 这个实际类型，而它表达的语义是 `Number` 以及 `Number` 的子类，因此赋值给一个 `Number` 类型的变量是合法的。但是下面的代码是不合法的： ```java public static void process(List numbers) { numbers.add(new Integer()); } ``` 这里同样可以想象一下 `List` 的 `add()` 方法的入参的泛型参数 `E` 就变成了 `? extends Number` 这个实际类型，它表达的语义是 `Number` 以及 `Number` 的子类，但是具体是哪个子类是无法确定的。上面的例子也解释了它可能是 `Number`，`Integer`，`Double` 等，假设它是 `Double` 类型，这里放一个 `Integer` 类型，又违背了泛型只能放 `Double` 的语义，因此这里的赋值是不合法的。 ### 无界通配符下面的代码就是定义了一个 `List\` 形参的方法，这里的 `List\` 语义是一个未知类型的 `List`。 ```java public static void printList(List list) {} ``` 无界通配符定义的 `List` 里面的元素只能赋值给 `Object` 类型。这里可以想象一下 `List` 的 `get()` 方法的泛型参数 `E` 就变成了 `?` 这个实际类型，它的语义是一个未知的类型，既然是一个未知的类型那么我只能赋值给 `Object` 类型的变量了。 ```java public static void printList(List list) { for (Object obj : list) { // do something } } ``` 无界通配符定义的 `List` 里面只能添加 `null`，不能添加其它的任何类型的元素，即使是 `Object` 也不行，因为添加了之后就会违背泛型的语义了。无界通配符的主要使用场景是： * 需要使用 `Object` 类中的方法 * 使用了泛型类中不用关心泛型的方法，比如 `List` 中的 `size()` ，`clear()` 方法 ### 下界通配符在使用上面的上界通配时，发现了一个问题，如果一个 `List` 类型形参声明为了上界通配符，是没有办法往这个 `List` 里面添加元素的，为了解决这个问题，可以使用下界通配符，可以定义如下的方法： ```java public static void addNumbers(List list) { list.add(new Integer()); list.add(new Double()); } ``` 这里可以想象一下这个时候 `List` 的 `add()` 方法的入参的泛型参数 `E` 就变成了 `? super Integer` 类型，它的语义是匹配 `Number` 以及 `Number` 类型的超类。根据 Java 多态的原理，这里实际可以传递的类型为 `Integer` 以及 `Integer` 的子类型，因为形参声明的是超类，实际传递子类的引用当然是合法的。 ## 泛型继承关系泛型的继承关系如下图所示： ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/2f679714caed4287b0558304a2504e5e~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=qKrIkCuAopjBGK0H5YpN6Q3ky8g%3D) ## 通配符捕获假设定义了一个无界限通配符的方法如下，这个方法会编译错误，因为按照之前分析的 `List\` 中不能添加任何类型的对象，而这里 `list.get(0)` 返回的是 `Object` 类型的对象，肯定是无法放入进去的。代码如下： ```java public void foo(List list) { list.set(0, list.get(0)); // 编译报错 } ``` 为了解决这个问题这个时候就可以通过新建一个私有的泛型方法来帮助捕获通配符的类型，这个私有的泛型方法名称通常是原有方法加上Helper后缀，这种技巧称为**通配符捕获**。代码如下： ```java pulic void foo(List list) { // 调用这个方法的语义是告诉编译器我不知道具体类型是什么， // 但是取出来和放进去的元素类型是相同的 fooHelper(list); } private void fooHelper(List list) { // 合法 T temp = list.get(0); // 合法 list.set(0, temp); } ``` 对于泛型方法，因为 `add()` 方法的入参，`get()` 方法返回值的泛型参数都是 `T`，当传入一个 `List` 进来，虽然这个 `List` 里面的对象实际类型不知道，但是通过泛型参数可以判断 `get()` 方法返回类型和 `add()` 方法的入参类型都是一样的，都是 T 捕获到的一个实际类型 `X`。对于带通配符参数的方法，因为方法的声明没有一个泛型参数，不能捕获到实际的参数类型 `X`。那么对于**每次方法的调用**编译器都会认为是一个不同的类型。比如编译器编译的时候 `list.set(0, xxx)`，这里的入参的类型就会是 `CAP#1`， `list.get(0)` 返回的类型就是 `CAP#2`，因为没有一个泛型参数来告诉编译器说 `CAP#1` 和 `CAP#2` 是一样的类型，因此编译器就会认为这两个是不同的类型，从而拒绝编译。下图是编译器实际的提示信息： ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/ef5dd38f798643b98c7cd53a84017b5a~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=femO1PEEC4k8DuiMq9wmUqkNRsg%3D) ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/ff4af7114928448fb8b9d0c27c98f7ae~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=lUZt%2Br4QxqSjEBsqQRXrgtQrH9w%3D) 从上面的图也可以看出，第二次调用方法时，类型又变成 `CAP#3` 和 `CAP#4` 了，这也证明了每次编译器都会认为是一个新的类型。实际上这里也可以将这个私有的 Helper 方法定义为公共的，然后去掉通配符的方法。这两种定义实际上是达到了相同的效果，但是 Java 语言规范 5.1.10 章节中更推荐采用通配符的方式定义，但它上面阐述的原因没太看懂，但是在另外一篇博客里面看到一个观点感觉有点道理。 ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/c91d320bfb6745f59912d58563bb9166~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=Jhd7IEY6ZYkhKWSE1bVyjGfVzmk%3D) 它说如果定义成一个泛型方法，那么老的遗留的没有用泛型的代码调用这个方法就会产生一个警告，但是如果是使用通配符则不会有警告产生。 ```java public static void foo1(List) {} public static void foo2(List) {} // 假设老的代码没有用泛型 List rawList = Arrays.asList("1", "2"); // 不会产生告警 foo1(rawList); // 会产生告警，提示未经检查的转换 foo2(rawList); ``` 然而实际上 JDK 中真正的实现并没有采用这种方式，而是直接用注解忽略了异常，直接用的原生类型来实现的。`Collections` 中的 `reverse()` 方法内部实现逻辑如下： ```java @SuppressWarnings({"rawtypes", "unchecked"}) public static void reverse(List list) { int size = list.size(); if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) { for (int i=0, mid=size>>1, j=size-1; i>1; i { public T data; public Node(T data) { this.data = data; } public void setData(T data) { System.out.println("Node.setData"); this.data = data; } } public class MyNode extends Node { public MyNode(Integer data) { super(data); } public void setData(Integer data) { System.out.println("MyNode.setData"); super.setData(data); } } ``` 泛型擦除后的实际代码如下，注意看 MyNode 里面的 `setData()` 方法并没有重写 Node 里面的 `setData()` 方法了，因为方法签名不一样。这就违背了 Java 多态的语义。 Java 编译器在编译的时候会自动给 MyNode 生成一个桥接方法，这个方法的签名和 `Node` 类里面的一样，然后在这个方法里面去调用真正的 `setData()` 方法。通过查看 MyNode.class 文件可以看到真的有两个 `setData()` 方法存在。 ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/a28d897a39a0495c9ec999cac8449330~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=P%2B3BcXjqAKvxB7JOpPiD6iIr9%2Bo%3D) 方法的形参类型是 `Object` 类型，和 `Node` 类中泛型擦除后的类型相同，说明这个方法才是真正重载了 `Node` 类中的方法。 ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/602e41df5b2c4eeb98b02cbb3118efe2~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=f%2BKTfthioMFn13D2xJtKAwn4P6M%3D) 方法实现中调用了 `MyNode` 类中形参为 `Integer` 类型的 `setData()` 方法。 ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/a5874358057a4279acfea6e6c3d214e9~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=hwVl%2BDNTbfJVdj1gZQ%2FGAJrXwns%3D) 同时在 `MyNode` 类中不允许自己定义形参为 `Object` 类型的 `setData()` 方法了，如果定义了则无法编译： ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/4adefa2c9f074a47b9ddad273778e036~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=kqAal%2Bax8ht6vDMHfbFZwd8K8yI%3D) 经过编译器编译后的代码等效为如下的代码： ```java public class Node { public Object data; public Node(Object data) { this.data = data; } public void setData(Object data) { System.out.println("Node.setData"); this.data = data; } } public class MyNode extends Node { public MyNode(Integer data) { super(data); } public void setData(Integer data) { System.out.println("MyNode.setData"); super.setData(data); } // 由编译器生成的桥接方法 // 如果手动定义了这个方法编译器就会报错了 public void setData(Object data) { setData((Integer) data); } } ``` ## 泛型的局限性 ### 泛型不能用于基本类型泛型是通过擦除实现的，擦除之后 `ArrayList` 内部是 `Object[]` 类型的数组，是不能存放基本类型的，因为基本类型不是 `Object` 类型的子类。 ```java List list = new ArrayList<>(); ``` ### 不能创建泛型类型的实例泛型是通过擦除来实现的，所以擦除之后都会变成 `new Object()` (没有指定上界的情况)，而实际上我们是要创建 `T` 类型的实例的。 ```java public static void test(List list) { E ele = new E(); list.add(ele); } // 可以通过如下方式 public static void test(List list, Class clazz) { E ele = clazz.newInstance(); list.add(ele); } // 调用 List list = new ArrayList<>(); test(list, String.class); ``` ### 不能声明静态的泛型变量泛型相当于是类的工厂，可以创建不同类型的实例。而静态变量是所有实例共享的，如果允许声明静态的泛型变量，那么不同类型的实例之间就会存在矛盾。 ```java public class MobileDevice { private static T os; } // 这两个实例的静态变量就会存在矛盾 MobileDevice phone = new MobileDevice<>(); MobileDevice pc = new MobileDevice<>(); ``` ### 不能使用 instanceof 判断泛型类型泛型是通过擦除实现的，因此 `List<\T>.class` 在内存中是不存在的，只有 `List.class`，这个类型也被称为原生类型。 ```java // 错误 if (list instanceof List) { } // 正确 if (list instanceof List) { } ``` ### 不能创建泛型数组泛型是通过擦除实现的，如果允许声明泛型数组，则无法实现数组在存放时会校验数组的元素类型这个语义。 ```java // 假设允许创建，这个数组的每个元素只允许存放 List 类型的元素 Object[] stringLists = new List[2]; // 正确执行 stringLists[0] = new ArrayList(); // 这行应该抛出 ArrayStoreException 异常， // 但是由于擦除，实际上和上面是一样的，这里违背了数组的语义 stringLists[1] = new ArrayList(); ``` ### 不能创建、捕获、抛出带泛型的异常 ```java // 编译报错 class MathException extends Exception {} // 编译报错 class QueueFullException extends Throwable {} // 编译报错 public static void execute(List jobs) { try { for (J job : jobs) } catch (T e) { // 编译报错 } } class Parser { // 这样是允许的 // 我觉得允许的原因是声明了抛出父类，而实际抛出子类也是合法的 public void parse(File file) throws T { } } ``` ### 不能使用擦除后原生类型相同的泛型参数方法来重载 ```java public class Example { // 这两个方法擦除后的参数是一样的，所以不能算重载 public void print(Set strSet) { } public void print(Set intSet) { } } ``` ## 堆污染当定义变长的泛型参数时，如果尝试把一个原生类型赋值给变成泛型参数就有可能发生堆污染。堆污染的本质原因就是可以通过语法糖变长参数列表来创建泛型的的数组导致的。例如下面的代码： ```java public class ArrayBuilder { public static void addToList (List listArg, T... elements) { for (T x : elements) { listArg.add(x); } } public static void faultyMethod(List... l) { // 这里编译应该会有告警，如果忽略这个告警，则有可能带来堆污染 Object[] objectArray = l; objectArray[0] = Arrays.asList(42); String s = l[0].get(0); } } ``` 编译告警中就会提示有堆污染，如下图所示： ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/6bde7179aad1442ab8c45edbbb01d879~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=%2FL8YiwhZ86dya%2Bikpj0z8t6N1XE%3D) 当编译器遇到一个变长参数方法时，它会把它转换为一个数组。对于 `T... elements` 这种参数声明就会转为 `T[] elements`，因为泛型的擦除，最终会被转换为 `Object[] elements`，这里编译器就会认为有可能发生堆污染。可以通过以下三种方式抑制这种警告： * `@SuppressWarnings({"unchecked", "varargs"})` 这种方式只能抑制方法声明时候的告警，方法调用处还是会产生告警； ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/dc3858c292e44323a172c356c3d8c284~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=abfw%2Ba0LZrATUOX3cLCfbJLZFT4%3D) * `@SafeVarargs` 不会产生任何警告 ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/9c2748c8b96b4360a65fed719de6d5e0~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=WIXx5iv4DZN7G4SjfSp5ipgxJAQ%3D) * 增加 `-Xlint:varags` 编译选项不会产生任何警告 ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/34e55a2c6e594862a25c8176b0ab36ed~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=3YsXp3H1qNLLkYuDpmlIb8R9vwM%3D) ## JVM 控制参数 ### 显示所有告警信息给编译器增加 `-Xlint:unchecked` ，在 Idea 中可以参考如下图配置： ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/ca2341005fdf4833950bc72f73726617~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=D4AajOGLKOpSIz7Rtyw8kEhJUiY%3D) ### 显示更详细的诊断信息给编译增加 `-Xdiags: verbose` 选项 ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/ac45eab531854a17b60556c41612289b~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=1epiiMswESVsx9ZYx%2FELzIWa53E%3D) ### 显示所有告警信息为英文增加如下环境变量： ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/297505cc9dce486dba67787ecdf39a97~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=Wwu3LdSOhaoLPpHaZg7Si31dnic%3D) Idea 中可以将配置放在 vmproperties 文件中，如下图所示： ![image.png](https://p9-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/6e08ea96c9234482ab179d9e3cd3443f~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAgamF2YWRheWRheXVw:q75.awebp?rk3s=f64ab15b&x-expires=1757476629&x-signature=xI8DvsycwgwNRIjIn1NgjKWbeEw%3D) ## 参考 [Java Generic Tutorial](https://docs.oracle.com/javase/tutorial/java/generics/index.html)\ [Java核心技术·卷 I（原书第10版）](https://book.douban.com/subject/26880667) [深入理解Java虚拟机（第3版）](https://book.douban.com/subject/34907497)\ [When to use generic methods and when to use wild-card?](https://stackoverflow.com/questions/18176594/when-to-use-generic-methods-and-when-to-use-wild-card)\ [Why use a wild card capture helper method?](https://stackoverflow.com/questions/30763895/why-use-a-wild-card-capture-helper-method)\ [Capture Conv: rev/reverse - what's the point?](https://forums.oracle.com/ords/apexds/post/capture-conv-rev-reverse-what-s-the-point-8796)\ [Difference between \ and \ in Java](https://stackoverflow.com/questions/4343202/difference-between-super-t-and-extends-t-in-java)\ [What is PECS (Producer Extends Consumer Super)?](https://stackoverflow.com/questions/2723397/what-is-pecs-producer-extends-consumer-super)\ [Differences between `copy(List dest, List src) ` and `copy(List dest, List src)`](https://stackoverflow.com/questions/34985220/differences-between-copylist-super-t-dest-list-extends-t-src-and-co)