14_Java泛型完全指南

Java泛型完全指南 —— 从入门到类型擦除

文章目录

• Java泛型完全指南 —— 从入门到类型擦除
• • 前言
  • 一、为什么需要泛型
  • • 1.1 没有泛型的时代
    • 1.2 有了泛型之后
  • 二、泛型类
  • • 泛型类的常见命名约定
    • 多类型参数的泛型类
  • 三、泛型方法
  • • 泛型方法的类型推断
  • 四、泛型接口
  • 五、泛型通配符
  • • 5.1 上界通配符（? extends T）
    • 5.2 下界通配符（? super T）
    • 5.3 PECS原则
  • 六、类型擦除
  • • 6.1 什么是类型擦除
    • 6.2 类型擦除的规则
    • 6.3 类型擦除的影响
  • 七、桥方法
  • 八、泛型的限制与注意事项
  • 总结
  • ✅ 亮点总结
  • 适用场景
  • 扩展方向

前言

**泛型（Generics）**是Java 5引入的最重要特性之一。在泛型出现之前，Java集合存在严重的安全隐患——任何类型的对象都可以放入同一个集合，取出时必须手动强转，类型错误只能在运行时暴露。泛型让编译器帮我们做类型检查，在编译期就能发现类型不匹配的问题。

泛型有两个核心价值：①类型安全——将运行时的ClassCastException提前到编译期发现，大幅降低生产事故率；②消除类型强转——代码更简洁、更可读。但Java泛型有一个独特之处：它是通过类型擦除实现的，这意味着泛型信息在编译后会被擦除，运行时List<String>和List<Integer>本质上是同一个List类。这一设计决策导致了泛型的一些限制（如不能创建泛型数组、不能用基本类型作为类型参数），也是面试中的高频考点。

本文将带你从泛型类、泛型方法、泛型接口三大基础概念出发，深入到类型擦除、通配符、泛型上下界以及PECS原则等高级话题，完整掌握Java泛型。

一、为什么需要泛型

1.1 没有泛型的时代

// 没有泛型（Java 1.4及以前）publicclassWithoutGenerics{publicstaticvoidmain(String[]args){Listlist=newArrayList();list.add("hello");list.add(123);// 可以放入任意类型list.add(newDate());// 完全合法，编译器不报错// 取出时必须强制转型Strings=(String)list.get(0);// String s2 = (String) list.get(1);// 运行时抛出 ClassCastException！}}

1.2 有了泛型之后

// 使用泛型publicclassWithGenerics{publicstaticvoidmain(String[]args){List<String>list=newArrayList<>();list.add("hello");// list.add(123); // 编译错误！类型不匹配Strings=list.get(0);// 不需要强制转型// 类型安全，简洁明了}}

泛型带来的好处显而易见：类型安全和消除强制转型。但还有第三个更深层的好处——代码可读性。当你看到List<String>时，立刻就知道这是一个字符串列表，不需要看注释也不用翻找代码。而看到一个裸的List时，你完全不知道里面存的是什么。这种"自文档化"的能力在大型项目中价值巨大——减少了理解代码所需的上下文查找时间。

面试题：为什么List<String>不能赋值给List<Object>？即使String是Object的子类？答案就是泛型不协变（invariant）。如果这种赋值被允许，那就可以向List<Object>中放入Integer，而原List<String>的调用者取出时就会得到ClassCastException——这就破坏了泛型的类型安全承诺。

二、泛型类

泛型类是在类名后使用<T>声明类型参数的类。T是类型参数，可以使用任意字母（但推荐使用有意义的单字母）。

/** * 泛型容器类 * T - 存储的元素类型 */publicclassBox<T>{privateTcontent;publicvoidset(Tcontent){this.content=content;}publicTget(){returncontent;}publicbooleanisEmpty(){returncontent==null;}}// 使用示例publicclassGenericClassDemo{publicstaticvoidmain(String[]args){// 存储字符串Box<String>stringBox=newBox<>();stringBox.set("你好，世界");Stringmessage=stringBox.get();System.out.println(message);// 存储整数Box<Integer>intBox=newBox<>();intBox.set(42);intvalue=intBox.get();// 自动拆箱，不用强转System.out.println(value);}}

泛型类的常见命名约定

字母	含义	典型场景
E	Element	集合元素（List<E>）
K	Key	Map的键
V	Value	Map的值
T	Type	通用类型
S, U, V	第2、3、4个类型	多个类型参数时
?	通配符	泛型通配符

多类型参数的泛型类

publicclassPair<K,V>{privateKkey;privateVvalue;publicPair(Kkey,Vvalue){this.key=key;this.value=value;}publicKgetKey(){returnkey;}publicVgetValue(){returnvalue;}}// 使用Pair<String,Integer>pair=newPair<>("年龄",25);System.out.println(pair.getKey()+": "+pair.getValue());// 年龄: 25

三、泛型方法

泛型方法是在方法返回值前声明类型参数的方法，类型参数只在当前方法内有效。

publicclassGenericMethodExample{/** * 泛型方法：交换数组中任意两个元素的位置 * <T> 表示声明了一个泛型类型参数T */publicstatic<T>voidswap(T[]array,inti,intj){Ttemp=array[i];array[i]=array[j];array[j]=temp;}/** * 泛型方法：查找元素在数组中的索引 */publicstatic<T>intindexOf(T[]array,Ttarget){for(inti=0;i<array.length;i++){if(array[i].equals(target)){returni;}}return-1;}publicstaticvoidmain(String[]args){// 操作字符串数组String[]names={"Alice","Bob","Charlie"};swap(names,0,2);System.out.println(Arrays.toString(names));// [Charlie, Bob, Alice]// 操作整数数组Integer[]numbers={1,2,3,4,5};intidx=indexOf(numbers,3);System.out.println("3的索引: "+idx);// 3的索引: 2}}

泛型方法的类型推断

Java编译器能根据传入的参数自动推断类型参数，大多数情况下不需要显式指定：

// 自动推断，不需要写 GenericMethodExample.<Integer>swap(numbers, 0, 1)swap(numbers,0,1);// 极少数需要显式指定的情况GenericMethodExample.<String>swap(names,1,2);

四、泛型接口

泛型接口是定义时带有类型参数的接口。

/** * 定义一个通用的数据访问接口 */publicinterfaceRepository<T>{TfindById(Longid);voidsave(Tentity);voiddelete(Longid);List<T>findAll();}/** * 针对User实体实现该接口 */publicclassUserRepositoryimplementsRepository<User>{privateList<User>storage=newArrayList<>();@OverridepublicUserfindById(Longid){returnstorage.stream().filter(u->u.getId().equals(id)).findFirst().orElse(null);}@Overridepublicvoidsave(Userentity){storage.add(entity);}@Overridepublicvoiddelete(Longid){storage.removeIf(u->u.getId().equals(id));}@OverridepublicList<User>findAll(){returnnewArrayList<>(storage);}}publicclassUser{privateLongid;privateStringname;// getter/setter省略publicLonggetId(){returnid;}}

五、泛型通配符

**通配符（?）**用于表示未知类型，常见于方法参数中。

5.1 上界通配符（? extends T）

表示类型必须是T或者T的子类，只能从集合中读取（生产者模式）：

publicclassUpperBoundDemo{// 可以接受 List<Number>、List<Integer>、List<Double> 等publicstaticdoublesum(List<?extendsNumber>list){doubletotal=0;for(Numbernum:list){total+=num.doubleValue();}returntotal;}publicstaticvoidmain(String[]args){List<Integer>intList=Arrays.asList(1,2,3,4,5);List<Double>doubleList=Arrays.asList(1.1,2.2,3.3);System.out.println(sum(intList));// 15.0System.out.println(sum(doubleList));// 6.6// 但无法向其中添加元素（除了null）List<?extendsNumber>list=newArrayList<Integer>();// list.add(10); // 编译错误！Numbernum=list.get(0);// 但可以读取}}

5.2 下界通配符（? super T）

表示类型必须是T或者T的父类，只能向集合中写入（消费者模式）：

publicclassLowerBoundDemo{// 可以将Integer及其父类的对象放入ListpublicstaticvoidaddNumbers(List<?superInteger>list){for(inti=1;i<=5;i++){list.add(i);// 可以添加Integer}}publicstaticvoidmain(String[]args){List<Number>numberList=newArrayList<>();List<Object>objectList=newArrayList<>();addNumbers(numberList);addNumbers(objectList);System.out.println(numberList);// [1, 2, 3, 4, 5]System.out.println(objectList);// [1, 2, 3, 4, 5]// 但读取时只能返回Object类型List<?superInteger>list=newArrayList<Number>();Objectobj=list.get(0);// 返回Object，需要强转}}

5.3 PECS原则

PECS是Producer Extends, Consumer Super的缩写，是使用通配符的黄金法则。这个原则回答了泛型编程中最常见的问题：“我该用? extends T还是? super T？”

直觉理解：

• 如果你要从集合中读取数据（集合是"生产者"），用? extends T——你可以安全地读取出T类型的数据（因为所有元素都是T的子类），但不能往里面写（因为不知道具体是哪个子类）
• 如果你要往集合中写入数据（集合是"消费者"），用? super T——你可以安全地写入T类型的数据（因为集合至少能容纳T），但读出来只能当Object处理
• 如果既要读又要写，那就不要用通配符，直接用具体的类型参数

这个原则在JDK源码中广泛使用，比如Collections.copy()方法就是经典的PECS应用。理解PECS之后，你看到List<? extends Number>就知道"只能从中读取Number"，看到List<? super Integer>就知道"只能往里面写入Integer"。

publicclassPECSPrinciple{// 从src中"生产"数据 → Extendspublicstatic<T>voidcopyFrom(List<?extendsT>src,List<?superT>dest){for(Titem:src){dest.add(item);// 向dest中"消费"数据 → Super}}publicstaticvoidmain(String[]args){List<Integer>src=Arrays.asList(1,2,3);List<Number>dest=newArrayList<>();copyFrom(src,dest);System.out.println(dest);// [1, 2, 3]}}

六、类型擦除

类型擦除是Java泛型最重要的底层机制，也是面试中最容易被追问的知识点。Java泛型本质上是编译器层面的语法糖，编译后泛型信息会被擦除。为什么Java选择类型擦除而不是像C#那样保留泛型信息（reified generics）？这是历史原因——Java 5引入泛型时必须兼容Java 4及之前的海量字节码，所以选择了"编译时检查，运行时擦除"的方案。类型擦除带来了一些限制，但同时也使得Java泛型能够无缝融入已有的JVM生态。

理解类型擦除，你才能真正理解为什么List<String>不能赋值给List<Object>（即使String是Object的子类）、为什么不能创建泛型数组、为什么不能在静态方法中使用类的类型参数。

6.1 什么是类型擦除

publicclassTypeErasureDemo{publicstaticvoidmain(String[]args){List<String>stringList=newArrayList<>();List<Integer>integerList=newArrayList<>();// 运行时，二者的Class对象是相同的System.out.println(stringList.getClass()==integerList.getClass());// 输出：true，都是java.util.ArrayList// 无法通过反射获取泛型类型信息System.out.println(stringList.getClass().getTypeParameters());}}

6.2 类型擦除的规则

1. 泛型类型变量擦除为它的第一个上界（没指定则为Object）
2. 方法签名中的泛型也会被替换

// 编译前publicclassGenericHolder<T>{privateTdata;publicTgetData(){returndata;}publicvoidsetData(Tdata){this.data=data;}}// 编译后（反编译结果等价于）publicclassGenericHolder{privateObjectdata;publicObjectgetData(){returndata;}publicvoidsetData(Objectdata){this.data=data;}}// 如果有上界publicclassNumberHolder<TextendsNumber>{privateTdata;publicTgetData(){returndata;}}// 编译后：T被替换为NumberpublicclassNumberHolder{privateNumberdata;publicNumbergetData(){returndata;}}

6.3 类型擦除的影响

publicclassErasureImpact{publicstaticvoidmain(String[]args){// 1. 无法创建泛型数组// List<String>[] stringLists = new List<String>[10]; // 编译错误// 2. 无法用instanceof直接判断泛型类型List<String>list=newArrayList<>();// if (list instanceof List<String>) { } // 编译错误// 3. 泛型信息可以通过反射获取的场景有限// 方法参数、字段、方法返回值的泛型可以通过Type获取// 但局部变量的泛型信息完全丢失}}

七、桥方法

类型擦除会带来多态冲突，编译器通过生成**桥方法（Bridge Method）**来解决：

// 定义一个泛型父类publicclassNode<T>{privateTdata;publicNode(Tdata){this.data=data;}publicvoidsetData(Tdata){System.out.println("Node.setData");this.data=data;}}// 子类指定具体类型publicclassMyNodeextendsNode<Integer>{publicMyNode(Integerdata){super(data);}// 编译器会自动生成桥方法：// public void setData(Object data) {// setData((Integer) data); // 类型强转后调用实际方法// }@OverridepublicvoidsetData(Integerdata){System.out.println("MyNode.setData");super.setData(data);}}

八、泛型的限制与注意事项

publicclassGenericLimitations{// 1. 不能用基本类型作为类型参数// List<int> list = new ArrayList<>(); // 错误！List<Integer>list=newArrayList<>();// 正确，用包装类// 2. 不能实例化类型参数// public <T> T create() {// return new T(); // 编译错误！// }// 解决方案：传递Class对象public<T>Tcreate(Class<T>clazz)throwsException{returnclazz.getDeclaredConstructor().newInstance();}// 3. 不能在静态字段中使用类型参数// private static T instance; // 编译错误！// 4. 泛型类不能继承Throwable// class GenericException<T> extends Exception { } // 编译错误！}

总结

Java泛型虽然因为类型擦除而受到一些限制，但它仍然是Java类型安全体系中最重要的一环。掌握泛型类、泛型方法、泛型接口以及通配符的使用，理解类型擦除的原理和影响，是每个Java开发者走向高级的必经之路。

核心知识回顾：

• 泛型类/方法/接口：提供编译期类型检查，消除运行时ClassCastException风险
• 通配符：? extends T（上界，生产者，只能读）和? super T（下界，消费者，只能写）各有适用场景
• PECS原则：Producer Extends, Consumer Super——这是选择通配符的一劳永逸法则
• 类型擦除：编译后泛型信息被擦除为Object或上界类型；桥方法是编译器为保证多态正确性自动生成的
• 常见限制：不能实例化类型参数（需要传Class对象）、不能创建泛型数组、静态方法不能使用类的类型参数

PECS原则、桥方法、类型擦除后的反编译结果——这些面试高频考点，现在你应该已经能够从容应对了。当面试官问"Java泛型是真泛型还是假泛型？"时，你就知道这指的是"类型擦除"机制：编译期是真泛型，运行时是假泛型。

✅ 亮点总结

• 泛型类、泛型方法、泛型接口的完整语法与使用模式，覆盖声明到调用的全链路
• PECS原则（Producer Extends, Consumer Super）是通配符选型的黄金法则，读用extends、写用super
• 类型擦除是理解泛型限制的关键，擦除后泛型变量被替换为上界或Object
• 桥方法（Bridge Method）是编译器自动生成的，保证泛型多态在类型擦除后依然正确
• 泛型的常见限制（不能实例化类型参数、不能用于static字段、不能创建泛型数组）及对应的解决方案

适用场景

• 开发通用DAO/Repository层数据访问接口，统一增删改查的方法签名
• 构建可复用的工具类和算法组件，如通用缓存容器、树/图数据结构
• 设计类型安全的回调处理框架，确保编译期类型检查，减少运行时ClassCastException

扩展方向

• 深入学习Kotlin的泛型特性（reified关键字、声明处型变），对比Java的类型使用差异
• 研究Spring框架中的泛型应用，如GenericTypeResolver如何解析泛型参数
• 推荐阅读：15_Java多线程入门

---

下一篇：15_Java多线程入门