一、泛型:Java类型系统的基石
泛型(Generics)是Java 5引入的核心特性,它使类型参数化成为可能,极大增强了类型安全与代码复用性
〈什么是泛型?〉
泛型即参数化类型(Parameterized Types),允许在定义类、接口、方法时使用类型参数。例如:
public class Box<T> {
private T value;
public void set(T value) { this.value = value; }
public T get() { return value; }
}
此处
⚠️ 注意:泛型不能用于基本类型——Box<int>非法,必须使用包装类Box<Integer>。
〔为什么需要泛型?〕
无泛型时代(JDK 1.4前),集合操作依赖Object类型,存在三大隐患:
- 运行时ClassCastException风险(如
List list = new ArrayList(); list.add("abc"); Integer i = (Integer)list.get(0);) - 强制类型转换冗余(每次取出需显式转换)
- API文档不自明(无法从签名获知元素类型)
泛型将类型安全从运行时提前至编译期,实现:零成本抽象(Zero-cost abstraction)——运行时无额外开销,仅编译时校验。
〔泛型的三大核心价值〕
- 类型安全:编译期捕获类型错误,避免运行时异常
- 消除强转:自动类型推导,代码更简洁(如
String s = list.get(0);) - 提升可读性:方法签名即契约(如
Map<K, V>一眼知其结构)
二、类型擦除:泛型的底层机制
理解类型擦除是掌握泛型的关键——它解释了为何泛型不能用于基本类型、静态上下文及instanceof
⚡ 什么是类型擦除?
Java泛型仅存在于源码层,编译后泛型信息被擦除:
- 无上界类型参数→替换为Object
- 有上界(extends)→替换为上界类型
- 泛型方法→插入桥接方法(Bridge Method)保证多态
示例:编译前
public class Pair<T, U> {
private T first;
private U second;
public Pair(T first, U second) {
this.first = first;
this.second = second;
}
}
编译后等价于:
public class Pair {
private Object first;
private Object second;
public Pair(Object first, Object second) {
this.first = first;
this.second = second;
}
}
〔桥接方法:保障泛型多态性〕
考虑继承场景:
class MyPair extends Pair<String, String> {
@Override
public void setFirst(String first) { ... }
}
编译器自动生成桥接方法:
public void setFirst(Object first) {
setFirst((String) first); // 类型强转
}
确保运行时方法签名一致,实现多态调用。可通过javap -v MyPair.class验证。
〔类型擦除带来的限制〕
- ❌ 不能实例化类型参数:
new T()非法 - ❌ 不能使用instanceof检查泛型类型:
if (obj instanceof List<String>)编译错误 - ❌ 静态上下文不能引用类型参数:
static T count;非法 - ❌ 不能创建泛型数组:
new T[10]非法,但T[] arr = (T[])new Object[10]可编译(有警告)
💡 替代方案:使用Arrays.asList()、集合类或反射创建数组(需传入Class对象)。
三、通配符:灵活的类型表达
通配符(?)解决泛型不可变性问题,实现更灵活的类型兼容
〔? extends E〕上界通配符
限定类型上界,只能读取(生产者),不能写入(除null外):
void printNumbers(List<? extends Number> list) {
for (Number n : list) { // 可安全读取为Number
System.out.println(n);
}
// list.add(1); // 编译错误!未知具体类型
}
适用场景:只读集合,如遍历、计算总和等
〔? super E〕下界通配符
限定类型下界,只能写入(消费者),读取时需强转:
void addIntegers(List<? super Integer> list) {
list.add(1); list.add(2); // 可写入Integer
Object o = list.get(0); // 只能读为Object
}
适用场景:仅写入,如收集数据到集合
〔?〕无界通配符
当操作不依赖具体类型时使用,等价于List<Object>但更安全:
int size(List<?> list) {
return list.size(); // 仅调用通用方法
}
⚠️ 注意:与List<Object>不同!List<String>不能赋值给List<Object>,但可赋值给List<?>
〔PECS原则:Producer Extends, Consumer Super〕
记忆口诀:生产者用extends,消费者用super
| 角色 | 通配符 | 操作 | 示例 |
|---|---|---|---|
| 生产者(读) | ? extends T | 获取数据 | Stream.of(list).map(T::method) |
| 消费者(写) | ? super T | 存入数据 | list.add(new T()) |
| 仅读取通用方法 | ? | 不依赖类型 | list.size() |
经典案例:Collections.copy(List<? super T> dest, List<? extends T> src)
四、边界类型:泛型的约束机制
上界(extends)和下界(super)为泛型参数添加约束,确保类型安全
〔上界泛型:extends关键字〕
定义:指定类型参数必须是某类的子类(含自身)
class Box<T extends Comparable<T>> {
private T value;
public int compareTo(Box<T> other) {
return this.value.compareTo(other.value);
}
}
效果:T可调用Comparable所有方法,编译器确保类型安全
〔多重边界:&连接〕
同时指定多个上界(类在前,接口在后):
class Processor<T extends Number & Comparable<T>> {
public double process(T a, T b) {
return a.doubleValue() + b.doubleValue();
}
}
限制:T必须同时是Number子类且实现Comparable
〔下界泛型:super关键字〕
较少用,但关键场景必备(如逆变):
void fill(List<? super Integer> list) {
list.add(1); list.add(2);
}
下界允许向集合中添加Integer及其子类(但Integer无子类),读取时需强转为上界类型
〔边界与类型擦除关系〕
上界存在时,擦除为上界类型:
List<? extends Number>→ 擦除为List<Number>List<? super Integer>→ 擦除为List<Object>
影响桥接方法生成,确保类型兼容性
五、泛型方法:独立于类的类型参数
泛型方法可定义在普通类中,类型参数仅作用于该方法
〔泛型方法定义格式〕
类型参数置于返回值前:
public <T> T getFirst(List<T> list) {
return list.get(0);
}
注意:<T>必须在返回类型前声明
〔显式与隐式类型推导〕
通常由编译器自动推导:
List<String> list = Arrays.asList("a", "b");
String s = getFirst(list); // T推导为String
也可显式指定(冗余但清晰):
String s = getFirst(list);
〔静态泛型方法〕
静态方法可声明泛型参数(因不依赖实例):
class Utils {
public static <T> List<T> asList(T... args) {
return Arrays.asList(args);
}
}
调用:Utils.asList(1, 2, 3) → List<Integer>
〔泛型方法与泛型类的区别〕
| 维度 | 泛型类 | 泛型方法 |
|---|---|---|
| 作用域 | 整个类 | 单个方法 |
| 类型参数位置 | 类名后 | 返回值前 |
| 静态成员访问 | ❌ 不能引用类型参数 | ✅ 可用 |
| 典型用途 | 容器类(List, Map) | 工具方法(排序、比较) |
六、泛型类与接口:类型安全的容器
构建自定义泛型容器时需掌握类级别泛型设计
〔泛型类基本结构〕
public class Cache<K, V> {
private final Map<K, V> map = new HashMap<>();
public V put(K key, V value) {
return map.put(key, value);
}
public V get(K key) {
return map.get(key);
}
}
使用时需指定类型:Cache<String, User> cache = new Cache<>();
〔泛型接口实现〕
实现类可指定具体类型或保留泛型:
interface Generator<T> {
T generate();
}
// 实现类指定类型
class RandomStringGenerator implements Generator<String> {
public String generate() { return UUID.randomUUID().toString(); }
}
// 实现类保留泛型
class PairGenerator<T> implements Generator<Pair<T, T>> {
public Pair<T, T> generate() { ... }
}
〔泛型继承的注意事项〕
- 子类可缩小泛型参数:
class IntList extends ArrayList<Integer> - 子类可扩展泛型参数:
class MyList<E> extends ArrayList<E> - 避免类型擦除冲突:
class Box<T> { T get(){} } class SubBox extends Box<String> { String get(){}`会生成桥接方法
〔泛型与单例模式〕
泛型类无法实现单例(因类型参数不同即为不同类),但可通过工厂模式模拟:
class SingletonHolder {
private static final Map<Class<?>, Object> instances = new HashMap<>();
@SuppressWarnings("unchecked")
public static <T> T getInstance(Class<T> clazz) {
return (T) instances.computeIfAbsent(clazz, c -> {
try { return c.getDeclaredConstructor().newInstance(); }
catch (Exception e) { throw new RuntimeException(e); }
});
}
}
七、常见误区与陷阱
深入理解泛型必须避开这些高频错误
⚠️ 误区1:泛型数组创建
new T[10]编译错误,因类型擦除后无法确定实际类型
✅ 正确做法:T[] arr = (T[]) new Object[10];(有unchecked警告)
或使用集合:List<T> list = new ArrayList<>();
〔误区2:泛型与instanceof〕
无法直接使用instanceof检查泛型类型:
if (obj instanceof List<String>) // ❌ 编译错误
if (obj instanceof List) // ✅ 可用,但无法区分具体类型
替代方案:传入Class参数
static <T> boolean isListOfType(List<?> list, Class<T> clazz) {
return !list.isEmpty() && clazz.isInstance(list.get(0));
}
〔误区3:泛型静态成员〕
静态字段/方法不能引用类类型参数:
class Box<T> {
static T value; // ❌ 编译错误!
}
原因:类型参数在实例化时才确定,但静态成员在类加载时存在
〔误区4:泛型方法重载冲突〕
类型擦除后方法签名相同将导致冲突:
void print(List<String> list) {}
void print(List<Integer> list) {} // ❌ 编译错误!
因擦除后均为print(List)
〔误区5:泛型与异常处理〕
不能声明泛型异常类(因异常处理机制需在编译时确定类型):
class GenericException<T> extends Exception {} // ❌ 编译错误
但泛型方法可抛出具体类型异常:
void process() throws IOException { ... }
八、实战应用与最佳实践
结合真实场景,展示泛型的工程化应用
〔1. 实现通用比较器〕
class ComparatorChain<T> implements Comparator<T> {
private final List<Comparator<T>> comparators;
public ComparatorChain(List<Comparator<T>> comparators) {
this.comparators = comparators;
}
@Override
public int compare(T a, T b) {
for (Comparator<T> comp : comparators) {
int result = comp.compare(a, b);
if (result != 0) return result;
}
return 0;
}
}
使用:comparators.sort(new ComparatorChain<>(List.of(nameComp, ageComp)));
〔2. 泛型缓存装饰器〕
class CachingList<E> implements List<E> {
private final List<E> delegate;
private final Map<Integer, E> cache = new HashMap<>();
public E get(int index) {
return cache.computeIfAbsent(index, i -> delegate.get(i));
}
// 其他方法委托delegate...
}
〔3. 泛型工厂模式〕
class Factory<T> {
private final Class<T> clazz;
public Factory(Class<T> clazz) { this.clazz = clazz; }
public T create() {
try { return clazz.getDeclaredConstructor().newInstance(); }
catch (Exception e) { throw new RuntimeException(e); }
}
}
使用:Factory<User> userFactory = new Factory<>(User.class); User u = userFactory.create();
〔4. 泛型与Stream API结合〕
Map<String, List<Integer>> groupByLength(List<String> words) {
return words.stream()
.collect(Collectors.groupingBy(
String::length,
Collectors.mapping(String::hashCode, Collectors.toList())
));
}
〔5. 泛型工具类设计〕
public class GenericsUtils {
public static <T> T requireNonNull(T obj, String msg) {
if (obj == null) throw new NullPointerException(msg);
return obj;
}
public static <T> T defaultIfNull(T obj, T defaultValue) {
return obj != null ? obj : defaultValue;
}
}