Java 泛型详解：全面掌握类型安全与灵活性的利器
Java 泛型是自 Java 5 引入的一项关键特性，旨在提升代码的类型安全性和可复用性。泛型通过引入参数化类型，允许类、接口和方法操作具体类型的数据，而无需在定义时指定具体类型。本文将深入探讨 Java 泛型的基本概念、类型参数与界定、通配符的使用、泛型的限制与继承、类型擦除、桥方法、泛型数组的创建、反射中的泛型处理，以及泛型的高级用法。通过全面了解和掌握这些知识点，开发者可以编写出更加通用、灵活和安全的 Java 代码。
1. 泛型的基本概念
1.1 泛型类
泛型类允许在类定义中使用参数化类型。这意味着类可以操作某种特定类型的数据，而在实例化类时才指定这种类型。
public class Box<T> { private T t; public void set(T t) { this.t = t; } public T get() { return t; } }
使用泛型类时，具体的类型参数在实例化时确定：
Box<Integer> integerBox = new Box<>(); integerBox.set(10); Integer value = integerBox.get();
1.2 泛型接口
类似于泛型类，泛型接口允许在接口定义中使用参数化类型。
public interface Container<T> { void add(T item); T get(int index); }
实现泛型接口：
public class Box<T> implements Container<T> { private List<T> items = new ArrayList<>(); @Override public void add(T item) { items.add(item); } @Override public T get(int index) { return items.get(index); } }
1.3 泛型方法
泛型方法使得方法可以独立于类而操作某种特定类型的数据。泛型方法的类型参数放在方法的返回类型之前。
public class Util { public static <T> void printArray(T[] inputArray) { for (T element : inputArray) { System.out.printf("%s ", element); } System.out.println(); } }
调用泛型方法：
Integer[] intArray = {1, 2, 3, 4, 5}; Util.printArray(intArray);
2. 类型参数和类型参数界定
2.1 类型参数
类型参数是泛型中的占位符，通常用单个大写字母表示：
- E：元素（Element）
- K：键（Key）
- V：值（Value）
- N：数字（Number）
- T：类型（Type）
2.2 类型参数的界定
类型参数可以被限定，使得它只能是某个类或接口的子类或实现类。
public class Box<T extends Number> { private T t; public void set(T t) { this.t = t; } public T get() { return t; } }
这样，Box 类的实例只能接受 Number 类型及其子类作为类型参数。
多重界定
类型参数可以有多个边界，使用 & 符号进行分隔。
public class Box<T extends Number & Comparable<T>> { private T t; public void set(T t) { this.t = t; } public T get() { return t; } }
3. 通配符
通配符用于泛型中的未知类型。
3.1 无界通配符
无界通配符 <?> 表示未知类型，通常用于只读访问的场景。
public void printList(List<?> list) { for (Object element : list) { System.out.println(element); } }
调用方法：
List<String> stringList = Arrays.asList("one", "two", "three"); printList(stringList);
3.2 上界通配符
上界通配符 <? extends T> 表示类型是 T 或 T 的子类，通常用于读取的场景。
public void process(List<? extends Number> list) { for (Number number : list) { System.out.println(number.doubleValue()); } }
调用方法：
List<Integer> integerList = Arrays.asList(1, 2, 3); process(integerList);
3.3 下界通配符
下界通配符 <? super T> 表示类型是 T 或 T 的超类，通常用于写入的场景。
public void addNumbers(List<? super Integer> list) { list.add(1); list.add(2); }
调用方法：
List<Number> numberList = new ArrayList<>(); addNumbers(numberList);
4. 泛型的限制
- 不能使用基本类型作为类型参数，例如 Box 是非法的，必须使用包装类 Box。
- 静态成员中不能使用类型参数，因为类型参数是在实例化时确定的，而静态成员与实例无关。
- 实例创建时不能使用类型参数，例如 new T() 是非法的，因为类型参数在运行时被擦除。
- 泛型数组不能直接创建，例如 new T[10] 是非法的。可以通过创建 Object 数组并进行类型转换来间接实现：
T[] array = (T[]) new Object[10];
5. 泛型与继承
泛型支持继承，但需要注意类型兼容性。
class Parent<T> { } class Child<T> extends Parent<T> { } Parent<String> parent = new Parent<>(); Child<String> child = new Child<>();
但是，不能将 Parent 赋值给 Parent，因为泛型是不协变的。
泛型的协变和逆变
虽然泛型类型参数是不协变的，但是可以使用通配符来实现协变和逆变：
List<? extends Number> covariantList = new ArrayList<Integer>(); // 协变 List<? super Integer> contravariantList = new ArrayList<Number>(); // 逆变
6. 类型擦除
Java 的泛型在编译时会进行类型擦除，以保证与旧版本的 Java 兼容。类型擦除后，所有泛型信息都会被移除，替换为其限定的类型或 Object。
public class Box<T> { private T t; public void set(T t) { this.t = t; } public T get() { return t; } }
类型擦除后相当于：
public class Box { private Object t; public void set(Object t) { this.t = t; } public Object get() { return t; } }
7. 桥方法
在类型擦除过程中，为了保证类型安全，编译器会生成桥方法。例如：
class Parent<T> { public T method(T t) { return t; } } class Child extends Parent<String> { public String method(String t) { return t; } }
生成桥方法后：
class Child extends Parent<String> { public String method(String t) { return t; } public Object method(Object t) { return method((String) t); } // 桥方法 }
8. 泛型数组
由于类型擦除的限制，Java 不支持直接创建泛型数组。可以通过创建 Object 数组并进行类型转换来间接实现：
T[] array = (T[]) new Object[10];
9. 泛型的使用场景
泛型被广泛应用于 Java 的集合框架、定义自定义泛型类和方法、类型参数界定等场景。
- 集合框架：如 List、Set、Map<K, V> 等。
- 自定义泛型类和方法：提高代码的复用性和类型安全。
- 类型参数界定：如 Comparable 接口。
10. 泛型与反射
在使用反射时，泛型类型会被擦除为原始类型，无法直接获取泛型类型的信息。但可以通过反射获取泛型的实际类型参数。
import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; public class GenericTypeDemo<T> { public static void main(String[] args) { GenericTypeDemo<String> demo = new GenericTypeDemo<>(); Type type = demo.getClass().getGenericSuperclass(); if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); for (Type actualTypeArgument : actualTypeArguments) { System.out.println(actualTypeArgument); } } } }
11. 泛型擦除后的副作用
类型擦除会导致一些潜在的问题，例如类型转换异常和类型安全问题。
public class Box<T> { private T t; public void set(T t) { this.t = t; } public T get() { return t; } public static void main(String[] args) { Box<String> stringBox = new Box<>(); stringBox.set("Hello"); Box rawBox = stringBox; // 允许的，但是会有类型安全问题 rawBox.set(10); // 运行时异常：ClassCastException } }
12. 泛型的高级用法
12.1 泛型的嵌套
泛型类型可以嵌套使用，例如 Map<K, List>。
Map<String, List<Integer>> map = new HashMap<>();
12.2 类型推断
Java 7 引入了菱形操作符 <>，使得编译器可以推断泛型的类型参数，从而减少冗长的代码。
List<String> list = new ArrayList<>();
12.3 泛型的类型推导
Java 8 引入了更强大的类型推导机制，允许在方法调用中推导出类型参数。
public static <T> List<T> emptyList() { return new ArrayList<T>(); } List<String> list = emptyList();
13. 总结
Java 泛型极大地提高了代码的类型安全性和可复用性，使得代码更加通用和灵活。理解并掌握泛型的使用对于编写高质量的 Java 代码至关重要。通过深入了解泛型的各种特性和限制，可以更好地利用泛型来编写类型安全、灵活和高效的代码。
![[Java]泛型](https://ucc.alicdn.com/3mfxe2r26qbaq/developer-article1631767/20241030/17e695849c244f56b4c3cbc4e2bbb757.png?x-oss-process=image/resize,h_160,m_lfit)