1. 为什么我们需要泛型：从类型安全说起
2004年Java 5发布时引入的泛型特性，彻底改变了我们编写集合类代码的方式。还记得早期使用ArrayList时需要强制类型转换的日子吗？那时代码里充斥着这样的片段：
java复制List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); // 必须强制转换
这种写法存在两个致命问题：首先，编译器无法检查你放入的对象类型是否正确；其次，取出时必须进行显式类型转换。更糟糕的是，如果有人在集合中混入了错误类型的对象：
java复制list.add(42); // 编译通过，运行时才报错
String s = (String) list.get(1); // ClassCastException!
泛型的出现完美解决了这些问题。通过类型参数化，我们可以在编译期就捕获这类错误：
java复制List<String> list = new ArrayList<>();
list.add("hello");
// list.add(42); // 编译错误！
String s = list.get(0); // 自动类型转换
关键经验：泛型最大的价值在于将运行时可能出现的ClassCastException提前到编译期发现。根据Oracle官方统计，泛型可以减少约30%的类型相关运行时异常。
2. 泛型基础：从入门到精通
2.1 基本语法与类型参数
泛型类的基本声明形式是在类名后加<T>，其中T是类型参数（可以是任意标识符，但惯例用单个大写字母）：
java复制public class Box<T> {
private T content;
public void set(T content) {
this.content = content;
}
public T get() {
return content;
}
}
使用时指定具体类型：
java复制Box<String> stringBox = new Box<>();
stringBox.set("Java");
// stringBox.set(123); // 编译错误
String value = stringBox.get(); // 无需强制转换
2.2 泛型方法的特殊语法
泛型也可以应用于单个方法，语法略有不同：
java复制public <T> T genericMethod(T param) {
return param;
}
调用时类型可以显式指定或由编译器推断：
java复制String s = obj.<String>genericMethod("text"); // 显式
Integer i = obj.genericMethod(123); // 类型推断
2.3 类型擦除的真相
Java泛型是通过类型擦除实现的，这意味着泛型信息只在编译期存在，运行时会被擦除。例如：
java复制List<String> strings = new ArrayList<>();
List<Integer> integers = new ArrayList<>();
System.out.println(strings.getClass() == integers.getClass()); // 输出true！
这种设计带来了与原生类型(raw type)的兼容性，但也导致了一些限制。理解这一点对处理泛型边界情况至关重要。
3. 高级泛型技巧：超越基础用法
3.1 边界类型参数：灵活的类型约束
有时我们需要限制类型参数的范围，这时可以使用边界(bounded type parameters)：
java复制public <T extends Number> void processNumber(T number) {
// 只能接受Number及其子类
System.out.println(number.doubleValue());
}
多重边界也是允许的：
java复制public <T extends Number & Comparable<T>> T max(T a, T b) {
return a.compareTo(b) > 0 ? a : b;
}
避坑指南：边界类型中类必须放在接口前面，且最多只能有一个类边界。
<T extends String & Comparable<T>>是合法的，但<T extends Comparable<T> & String>会导致编译错误。
3.2 通配符：处理未知类型的艺术
通配符?提供了更灵活的类型关系处理能力：
java复制public void printList(List<?> list) {
for (Object elem : list) {
System.out.println(elem);
}
}
上界通配符和下界通配符分别用? extends和? super表示：
java复制// 上界通配符 - 生产者(Producer)
public double sum(List<? extends Number> numbers) {
double sum = 0;
for (Number num : numbers) {
sum += num.doubleValue();
}
return sum;
}
// 下界通配符 - 消费者(Consumer)
public void addNumbers(List<? super Integer> list) {
for (int i = 1; i <= 10; i++) {
list.add(i);
}
}
记住PECS原则(Producer Extends, Consumer Super)可以正确处理通配符的使用场景。
3.3 泛型与数组：微妙的兼容性
泛型与数组的交互存在一些限制：
java复制// 合法
List<String>[] lists = new List[10]; // 原生类型数组
// 非法
// List<String>[] lists = new List<String>[10]; // 编译错误
这是因为数组需要在运行时知道其元素类型以进行类型检查，而泛型由于类型擦除无法提供这一信息。替代方案是使用集合而非数组。
4. 实战应用：泛型在框架设计中的妙用
4.1 构建类型安全的工厂模式
泛型工厂可以避免类型转换，提高代码安全性：
java复制public interface Factory<T> {
T create();
}
public class StringFactory implements Factory<String> {
@Override
public String create() {
return "Hello, World!";
}
}
// 使用
Factory<String> factory = new StringFactory();
String product = factory.create(); // 无需类型转换
4.2 实现通用DAO模式
在数据访问层，泛型可以大幅减少重复代码：
java复制public interface GenericDao<T, ID> {
T findById(ID id);
List<T> findAll();
void save(T entity);
void delete(T entity);
}
public class UserDao implements GenericDao<User, Long> {
// 实现针对User的具体方法
}
4.3 构建灵活的策略模式
泛型使策略接口可以适应多种类型：
java复制public interface Validator<T> {
boolean validate(T input);
}
public class EmailValidator implements Validator<String> {
@Override
public boolean validate(String email) {
return email.matches("^[\\w-.]+@([\\w-]+\\.)+[\\w-]{2,4}$");
}
}
public class AgeValidator implements Validator<Integer> {
@Override
public boolean validate(Integer age) {
return age >= 18;
}
}
5. 泛型开发中的常见陷阱与解决方案
5.1 类型擦除带来的反射问题
由于类型擦除，运行时无法获取泛型的具体类型参数：
java复制List<String> strings = new ArrayList<>();
Class<?> clazz = strings.getClass();
Type type = clazz.getGenericSuperclass(); // 无法获取String类型信息
解决方案是使用TypeToken模式（如Gson库中的实现）：
java复制Type listOfString = new TypeToken<List<String>>() {}.getType();
5.2 无法实例化类型参数
以下代码无法编译：
java复制public class Container<T> {
private T instance;
public Container() {
instance = new T(); // 编译错误
}
}
替代方案是传入Class对象或使用Supplier：
java复制public class Container<T> {
private T instance;
public Container(Class<T> clazz) throws Exception {
instance = clazz.newInstance();
}
// 或使用Supplier
public Container(Supplier<T> supplier) {
instance = supplier.get();
}
}
5.3 方法重载的陷阱
以下重载会导致编译错误：
java复制public void process(List<String> list) {}
public void process(List<Integer> list) {} // 编译错误
这是因为类型擦除后两个方法的签名相同。解决方案是修改方法名或参数类型。
6. 现代Java中的泛型演进
6.1 Java 8的改进：目标类型推断
Java 8增强了类型推断能力：
java复制List<String> list = Collections.emptyList(); // Java 7需要显式类型参数
6.2 Java 10的var与泛型
var可以与泛型良好配合：
java复制var list = new ArrayList<String>(); // 推断为ArrayList<String>
6.3 未来可能的变化：值类型与泛型
Valhalla项目可能会引入对原始类型泛型的支持，解决当前List<int>不合法的问题。
7. 代码质量提升实践
7.1 使用泛型减少重复代码
比较以下两个方法：
java复制// 非泛型版本
public static String findMaxString(List<String> list) {
String max = list.get(0);
for (String s : list) {
if (s.compareTo(max) > 0) max = s;
}
return max;
}
public static Integer findMaxInteger(List<Integer> list) {
Integer max = list.get(0);
for (Integer i : list) {
if (i.compareTo(max) > 0) max = i;
}
return max;
}
// 泛型版本
public static <T extends Comparable<T>> T findMax(List<T> list) {
T max = list.get(0);
for (T elem : list) {
if (elem.compareTo(max) > 0) max = elem;
}
return max;
}
泛型版本不仅代码量减少，而且可以适用于任何实现了Comparable的类型。
7.2 通过泛型增强API安全性
考虑一个返回第一个非null元素的工具方法：
java复制// 非泛型版本 - 不安全
public static Object firstNonNull(Object... items) {
for (Object item : items) {
if (item != null) return item;
}
return null;
}
// 使用
String s = (String) firstNonNull(null, "default"); // 需要强制转换
// 泛型版本 - 类型安全
public static <T> T firstNonNull(T... items) {
for (T item : items) {
if (item != null) return item;
}
return null;
}
// 使用
String s = firstNonNull(null, "default"); // 自动类型推断
7.3 泛型与Optional的结合
java复制public static <T> Optional<T> findFirst(List<T> list, Predicate<T> predicate) {
for (T item : list) {
if (predicate.test(item)) {
return Optional.of(item);
}
}
return Optional.empty();
}
这种组合既保持了类型安全，又避免了null的使用。