深度解析泛型核心机制、语法原理与实战应用,覆盖从基础定义到高级技巧的完整知识体系,助您彻底掌握类型参数化设计思想,编写可复用、可维护、零类型转换风险的高质量代码。
在泛型出现前,Java集合框架(如ArrayList)只能存储Object类型。开发者需手动强制类型转换,极易引发ClassCastException运行时异常。
// 无泛型时代:类型不安全
List list = new ArrayList();
list.add("Hello");
list.add(123); // 编译通过!但逻辑错误
String s = (String) list.get(1); // 运行时抛出 ClassCastException
Java 定义泛型的核心价值在于:将类型检查从运行时提前至编译期,实现编译时类型安全。泛型是参数化类型(Parameterized Types)的语法糖——类型本身可作为参数传入类、接口或方法中。
例如:List表示“元素类型为String的列表”,而非“一个列表”。类型参数E(Element)在实例化时被具体类型替换。
ClassCastException<T>、<E>、<K>、<V>是约定俗成的类型参数名,遵循:T(Type):通用类型E(Element):集合元素K(Key)、V(Value):映射键值对
public class Box<T> {
private T content;
public void set(T content) {
this.content = content;
}
public T get() {
return content;
}
}
public class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
}
| 参数名 | 含义 | 典型场景 |
|---|---|---|
T |
Type | 通用类型 |
E |
Element | 集合元素(如ArrayList<E>) |
K |
Key | Map键(如HashMap<K,V>) |
V |
Value | Map值 |
R |
Result | 返回类型 |
S, U, ... |
Secondary/Upper | 后续类型参数 |
int),必须使用包装类(如Integer)new T()或T.class(因类型擦除)static T value非法)
public class GenericStack<E> {
private java.util.ArrayList<E> list = new java.util.ArrayList<>();
public int getSize() {
return list.size();
}
public E peek() {
return list.get(getSize() - 1);
}
public void push(E o) {
list.add(o);
}
public E pop() {
E o = list.get(getSize() - 1);
list.remove(getSize() - 1);
return o;
}
}
使用时:GenericStack<String> stack = new GenericStack<>();,编译器确保所有操作仅涉及String类型。
class SubStack<E> extends GenericStack<E>)class StringStack extends GenericStack<String>)class PairStack<K> extends GenericStack<Pair<K, Object>>)
public class IntegerStack extends GenericStack<Integer> {
// 仅接受Integer类型,无需类型参数
}
GenericStack stack = new GenericStack();(无类型参数)会绕过泛型检查,编译器发出unchecked警告。强烈建议:禁用原始类型!
原始类型与泛型类型不兼容:GenericStack<String> gs = new GenericStack();虽可编译,但会触发unchecked conversion警告,破坏类型安全。
<T>必须放在public/protected/private与返回类型之间,与类是否为泛型无关!
public class Utility {
// 静态泛型方法:交换数组元素
public static <T> void swap(T[] array, int i, int j) {
T temp = array[i];
array[i] = array[j];
array[j] = temp;
}
public static void main(String[] args) {
String[] names = {"Alice", "Bob", "Charlie"};
swap(names, 0, 2); // T被推断为String
}
}
public static <T> T getFirst(List<T> list) {
return list.get(0);
}
// 调用时自动推断类型
String first = getFirst(Arrays.asList("A", "B", "C"));
| 特性 | 泛型类中的方法 | 独立泛型方法 |
|---|---|---|
| 类型参数作用域 | 整个类 | 仅当前方法 |
| 是否依赖类泛型 | 是 | 否 |
| 典型场景 | 类内部操作(如Box.get()) |
工具类方法(如Collections.sort()) |
<T extends Comparable<T>>是常见边界限定模式(见后文)
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
// 错误:List不是List的子类型
// List animals = new ArrayList(); // 编译失败
// 正确:使用通配符
List extends Animal> animals = new ArrayList();
// 但无法添加元素(除null外),因编译器未知具体类型
? extends T表示“T的某个子类型”,? super T表示“T的某个父类型”。
// 读取安全:可安全读取为Animal类型
public static void printAnimals(List extends Animal> list) {
for (Animal a : list) {
System.out.println(a);
}
}
// 调用:支持任何Animal子类列表
printAnimals(new ArrayList());
printAnimals(new ArrayList());
通配符原则:PECS(Producer-Extends, Consumer-Super)
• 需要读取数据 → 使用? extends T
• 需要写入储>数据 → 使用? super T
// 写入安全:可安全添加Dog对象
public static void addDog(List super Dog> list) {
list.add(new Dog()); // Dog是Dog及父类的安全子类型
}
// 调用:支持Dog的父类列表
List animals = new ArrayList<>();
addDog(animals); // animals现在包含一个Dog
? extends T无法写入(add仅允许null)? super T无法安全读取(返回类型为Object)?等价于? extends Object
// 编译前(源代码)
public <T> T getFirst(List<T> list) { ... }
// 编译后(字节码)
public Object getFirst(List list) { ... }
类型参数T被替换为Object,并在必要位置插入强制转换(如return (T) list.get(0);)。
Object<T extends B>)→ 替换为上界Bclass MyList<T> extends ArrayList<Object> {
public void add(T t) { ... } // 重写add(Object)
}
// 编译器生成:
public void add(Object obj) {
add((T)obj); // 调用泛型版本
}
getTypeParameters())new T[10])public static <T extends Number> double sum(List<T> list) {
double total = 0;
for (T num : list) {
total += num.doubleValue();
}
return total;
}
// 调用:T必须是Number子类
sum(Arrays.asList(1, 2, 3)); // Integer
sum(Arrays.asList(1.5, 2.5)); // Double
上界限定确保T具有Number的所有方法(如doubleValue())。
public static <T super Integer> void increment(List<T> list) {
for (int i = 0; i < list.size(); i++) {
list.set(i, (T)(Integer)(list.get(i).intValue() + 1));
}
}
// 调用:T必须是Integer的父类
List nums = new ArrayList<>();
increment(nums); // nums中每个元素+1
public static <T extends Comparable<T> & Cloneable> void sortAndClone(List<T> list) {
Collections.sort(list); // 需Comparable
// Cloneable仅作类型约束,无法直接调用clone()
}
多边界中第一个必须是类(若存在),其余为接口;用&连接。
<T extends Comparable<T>>是泛型排序方法的黄金标准(如Collections.sort())<T super E>常用于生产者-消费者模式(如Collection.add())
// List接口定义
public interface List<E> extends Collection<E> {
E get(int index);
boolean add(E e);
// ...
}
// Map接口定义
public interface Map<K,V> {
V get(Object key);
V put(K key, V value);
// ...
}
| 场景 | 推荐写法 | 原因 |
|---|---|---|
| 声明变量 | List |
使用接口类型,右侧菱形运算符推断 |
| 返回类型 | public List<User> getUsers() |
暴露接口而非实现类 |
| 通配符参数 | public void print(List<? extends Animal> list) |
允许子类列表输入 |
public class ReadOnlyList<E> implements List<E> {
private final List<E> internalList;
public ReadOnlyList(List<E> list) {
this.internalList = list;
}
// 仅实现读操作
public E get(int index) { return internalList.get(index); }
public int size() { return internalList.size(); }
// 禁用写操作
public void add(E e) { throw new UnsupportedOperationException(); }
// ...
}
public class GenericClass<T> {
static T staticField; // ❌ 编译错误:静态字段不能引用实例类型参数
}
原因:类型擦除后T不存在,静态成员在类加载时初始化,无法绑定具体类型。
try { ... }
catch (GenericException<T> e) { ... } // ❌ 编译错误
Java禁止泛型异常类(因类型擦除后无法区分GenericException<String>与GenericException<Integer>)。
public void print(List<String> list) { ... }
public void print(List<Integer> list) { ... } // ❌ 编译错误:擦除后签名相同
类型擦除后两个方法均为print(List),违反重载规则。
// 错误:new T[10]
// 正确:使用Object数组并强制转换
public class GenericArray<T> {
private Object[] array;
private int size;
public GenericArray(int capacity) {
array = new Object[capacity]; // 允许
}
@SuppressWarnings("unchecked")
public T get(int index) {
return (T) array[index];
}
public void set(int index, T value) {
array[index] = value;
}
}
使用<T extends Comparable<T>>等边界确保类型具备必要能力,避免运行时ClassCastException。
方法参数用? extends T(读)或? super T(写),避免过度泛型化(如public <T> void method(List<T> list))。
禁用List list,始终使用List<String>。若无法避免(如旧API),用@SuppressWarnings("unchecked")并添加注释。
如Apache Commons的CollectionUtils,提供<T> boolean isEmpty(Collection<T> coll)等方法,复用类型推断逻辑。
? extends T,为写操作选? super T?