1. 为什么需要泛型？(The "Why")
在泛型被引入（JDK 5）之前，Java的集合类（如 ArrayList）是“存任何东西”的。这带来了两个主要问题：
- 类型不安全：你可以向一个本意是存放
String的ArrayList中添加一个Integer，编译器不会报错，但会在运行时取出元素并尝试转换时抛出ClassCastException。
- 代码繁琐：从集合中取出元素时，你得到的总是
Object类型，必须手动进行强制类型转换。
示例 (没有泛型):
// 本意是想创建一个只存放字符串的列表 List list = new ArrayList(); list.add("Hello"); list.add(123); // 编译时不会报错！// 取出元素时 for (int i = 0; i < list.size(); i++) {// 必须强制转换，当遇到整数123时，下面这行会抛出 ClassCastExceptionString str = (String) list.get(i); System.out.println(str); }
泛型的出现就是为了在编译时解决这些问题，将运行时错误提前到编译期。
2. 泛型的核心优势
- 编译时类型安全 (Compile-time Type Safety)：泛型允许你为集合或类指定一个类型。如果你尝试添加不匹配的类型，编译器会直接报错。
// 使用泛型 List<String> list = new ArrayList<>(); list.add("Hello"); // list.add(123); // 编译时直接报错！
- 消除强制类型转换 (Elimination of Casts)：从泛型集合中获取元素时，你得到的就是指定类型的数据，不再需要手动强制转换，使代码更简洁、更安全。
String str = list.get(0); // 无需强制转换
3. 泛型的使用
3.1 泛型类 (Generic Class)
在定义类时，使用 <T> (T通常代表Type) 来声明一个类型参数。
public class Box<T> {private T item;public void setItem(T item) {this.item = item;}public T getItem() {return item;} }// 使用 Box<String> stringBox = new Box<>(); stringBox.setItem("Hello World"); String content = stringBox.getItem();
3.2 泛型方法 (Generic Method)
在方法的返回类型前声明类型参数，该参数的作用域仅限于此方法。
public class Utils {public static <T> T getFirst(List<T> list) {if (list == null || list.isEmpty()) {return null;}return list.get(0);} }
4. 泛型中的通配符 (Wildcards)
通配符 ? 用于处理不确定类型的泛型，它增强了泛型的灵活性和类型安全性，主要用在方法参数、字段或局部变量上。
4.1 上界通配符 (Upper Bounded Wildcard): ? extends Type - 生产者 (Producer)
- 含义：表示一个泛型集合，其元素类型是
Type本身，或者是Type的任意子类型。
- 读写权限 (PECS - Producer)：
- 读 (Get)：安全。你可以从中读取元素，取出的元素可以被确认为
Type类型或其父类型，因此可以安全地赋值给Type类型的变量。
- 写 (Add)：不安全，几乎不能写入非
null元素。因为编译器无法确定?究竟代表Type的哪个具体子类型，为了防止类型不匹配，除了null之外，任何元素都不能放入。
- 适用场景：当你的方法主要需要从集合中读取数据时（将集合视为数据的生产者）。
// 可以接受 List<Number>, List<Integer>, List<Double> 等 public void processNumbers(List<? extends Number> list) {for (Number num : list) { // 读取是安全的，因为任何元素都是Number System.out.println(num.doubleValue());}// list.add(123); // 编译错误！无法确定列表的具体类型，为了类型安全禁止写入list.add(null); // 写入 null 是允许的，因为 null 可以是任何类型 }
4.2 下界通配符 (Lower Bounded Wildcard): ? super Type - 消费者 (Consumer)
- 含义：表示一个泛型集合，其元素类型是
Type本身，或者是Type的任意父类型。
- 读写权限 (PECS - Consumer)：
- 读 (Get)：不安全，你只能将取出的元素视为
Object类型。因为你不知道?究竟代表Type的哪个具体父类，但Object肯定是所有父类型的共同祖先。
- 写 (Add)：安全。你可以向其中写入
Type及其任意子类型的对象。因为任何Type及其子类型都可以安全地向上转型，并存入Type的任意父类型的集合中。
- 适用场景：当你的方法主要需要向集合中写入数据时（将集合视为数据的消费者）。
// 可以接受 List<Integer>, List<Number>, List<Object> public void addIntegers(List<? super Integer> list) {list.add(1); // 写入 Integer 及其子类型（如 int 的自动装箱）是安全的list.add(new Integer(2));// list.add(new Number()); // 编译错误！Number 不是 Integer 的子类 Object obj = list.get(0); // 读取出来只能是 Object 类型// Integer i = list.get(0); // 编译错误！不确定是 Integer 的哪个父类 }
4.3 无界通配符 (Unbounded Wildcard): ?
- 含义：表示“任何类型”，等同于
? extends Object。
- 读写权限：
- 读 (Get)：只能读取为
Object类型。
- 写 (Add)：不能写入任何元素（除了
null）。
- 适用场景：当你对集合中的元素类型完全不关心，只需要用到与类型无关的方法时（如
list.size()或list.clear()），或者验证参数是否为泛型类型时。
4.4 PECS 原则总结
PECS (Producer Extends, Consumer Super) 原则是一个方便记忆通配符使用场景的口诀：
Producer Extends：如果你要从一个泛型集合中取数据（即该集合是数据的生产者），那么使用<? extends T>。
Consumer Super：如果你要往一个泛型集合中放数据（即该集合是数据的消费者），那么使用<? super T>。
这个原则是理解和正确使用泛型通配符的关键。
5. 泛型的工作原理：类型擦除 (Type Erasure)
这是 Java 泛型的一个核心和特点。为了保证与旧版本 Java 代码的兼容性，Java 泛型在编译后，其大部分类型信息会被“擦除”。
5.1 类型擦除的原理
- 检查与替换：编译器会首先检查泛型代码的类型安全性，然后将泛型类型（如
<T>）替换为它的上界（bound）。如果没有指定上界（如Box<T>），则默认为Object；如果指定了上界（如<T extends Number>），则替换为Number。
- 插入强制类型转换：在需要的地方，编译器会自动插入强制类型转换的代码。
- 结果：最终生成的字节码（
.class文件）中不包含泛型类型信息。因此，ArrayList<String>和ArrayList<Integer>在运行时其实是同一个类：ArrayList。
示例：
// 源码 List<String> list = new ArrayList<>(); list.add("test"); String s = list.get(0);// 编译后（概念上） List list = new ArrayList(); list.add("test"); String s = (String) list.get(0); // 编译器自动加入了强制转换
5.2 类型擦除带来的局限性
由于类型擦除，泛型在 Java 中有一些天然的限制：
- 不能创建泛型类型的实例：
new T()(错误)。因为T在运行时已经被擦除，JVM 不知道要实例化哪个类。
- 不能创建泛型数组：
new T[5](错误)。原因同上。
- 不能在
instanceof中使用泛型类型：if (obj instanceof Box<String>)(错误)。因为运行时只有Box，没有<String>的信息。
- 泛型类的静态上下文中不能引用类型参数：静态方法或静态变量属于类本身，在类加载时就已存在。而类型参数
T是在创建对象实例时才被指定的，因此静态上下文无法访问T。
5.3 解决方案：桥接方法 (Bridge Methods)
问题：类型擦除似乎会破坏Java的多态性。当子类重写了父类或接口中带有泛型的方法时，由于类型擦除，子类的方法签名（例如 compareTo(String)) 与父类/接口被擦除后的方法签名（例如 compareTo(Object)）不完全匹配。
解决方案：为了保持多态性，并让子类能够真正地覆盖（Override）父类的方法，编译器会自动在子类中生成一个我们看不到的桥接方法。这个桥接方法的方法签名与父类被擦除后的一致（例如 compareTo(Object)），其内部会调用我们自己实现的那个带有具体类型参数的方法（compareTo(String)）。它就像一座“桥”，连接了泛型和非泛型的世界，保证了多态的正常工作。
示例：
class MyString implements Comparable<String> {// 我们重写的是这个方法public int compareTo(String other) {// ... return 0;} }// Comparable 接口在类型擦除后是这样的： // interface Comparable { // public int compareTo(Object other); // }
为了让 MyString 类真正实现 Comparable 接口，编译器会自动生成一个我们看不到的桥接方法：
// 编译器自动生成的、我们看不见的桥接方法 public int compareTo(Object other) {// 内部调用我们写的那个具体方法return compareTo((String) other); }
5.4 特例：通过反射获取泛型信息
虽然类型擦除会移除大部分泛型信息，但在某些特定情况下（主要是在类的签名、方法的签名或字段的签名中），我们仍然可以通过反射获取它们。
例如，一个类继承了另一个泛型类：
class StringList extends ArrayList<String> { ... }// 我们可以通过反射获取到父类 ArrayList 的泛型参数是 String Type type = StringList.class.getGenericSuperclass(); ParameterizedType pt = (ParameterizedType) type; System.out.println(pt.getActualTypeArguments()[0]); // class java.lang.String
像 Gson、Fastjson 这类JSON库就是利用这种技术（以及 TypeToken 模式）来实现对泛型对象的反序列化的。
6. 其他高级主题
6.1 泛型与继承
一个常见的误区是认为 List<String> 是 List<Object> 的子类，这是错误的。在泛型中，类型参数的继承关系不能传递给容器本身
List<String> stringList = new ArrayList<>(); // List<Object> objectList = stringList; // 编译错误！
原因：如果这个赋值是允许的，那么我们就可以通过 objectList.add(123) 向一个只应该存放 String 的列表中添加 Integer，这会破坏泛型的类型安全承诺，最终在 stringList.get() 时导致 ClassCastException。
6.2 自限定类型 (Self-Bounding Types)
这是一种常见的泛型模式，用于强制类型参数必须是自身的子类型。最典型的例子是 Enum 和 Comparable。
public abstract class Enum<E extends Enum<E>> implements Comparable<E> { ... }
这里的 <E extends Enum<E>> 确保了任何枚举类型都只能与它自己进行比较，避免了 ColorEnum.compareTo(SizeEnum) 这种无意义的比较。
6.3 堆污染 (Heap Pollution)
- 定义：当一个参数化类型（如
List<String>）的变量指向了一个非该类型（如List<Integer>）的对象时，就发生了堆污染。
- 原因：这通常发生在将参数化类型与原始类型或可变参数（varargs）混合使用时。
@SafeVarargs：当一个泛型方法使用了可变参数，并且开发者确信方法体内的操作不会导致堆污染时，可以使用@SafeVarargs注解来抑制编译器的警告。