Java泛型是一种强大的工具，允许开发者在编写代码时使用类型参数，从而提高代码的灵活性和类型安全性。本文将结合代码示例和具体的使用场景，详细讲解Java泛型的原理和使用方法。
1. 泛型的基本概念
泛型允许在定义类、接口和方法时使用类型参数，这样在实例化或调用时可以指定具体的类型。通过泛型，可以在编译时进行类型检查，避免运行时的类型转换错误，从而提高代码的健壮性。
1.1 泛型类的定义与使用
泛型类通过在类名后使用尖括号 <> 指定类型参数。例如，我们可以定义一个简单的泛型类 Box：
public class Box<T> {
private T content;
public void setContent(T content) {
this.content = content;
}
public T getContent() {
return content;
}
}
在这里，T 是一个类型参数，可以代表任何类型。使用时，我们可以指定具体的类型：
public static void main(String[] args) {
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello");
String content = stringBox.getContent(); // 无需类型转换
System.out.println(content); // 输出: Hello
Box<Integer> integerBox = new Box<>();
integerBox.setContent(123);
Integer number = integerBox.getContent();
System.out.println(number); // 输出: 123
}
在这个例子中，Box<String> 和 Box<Integer> 分别存储字符串和整数，编译器会确保类型安全，避免错误。
1.2 泛型方法的定义与使用
泛型方法是在方法声明中定义类型参数。例如，一个打印数组内容的泛型方法：
public <T> void printArray(T[] array) {
for (T element : array) {
System.out.println(element);
}
}
使用示例：
public static void main(String[] args) {
String[] strings = {"a", "b", "c"};
Integer[] integers = {1, 2, 3};
printArray(strings); // 输出: a b c
printArray(integers); // 输出: 1 2 3
}
这个方法可以接受任何类型的数组，展示了泛型的灵活性。
2. 泛型的原理
Java泛型的实现依赖于类型擦除（Type Erasure）。在编译时，编译器会将泛型类型参数替换为具体的类型（通常是 Object），并在必要时插入类型转换代码。因此，在运行时，泛型信息会被擦除，生成的字节码中不包含类型参数。
2.1 类型擦除的示例
考虑以下代码：
Box<String> stringBox = new Box<>();
Box<Integer> integerBox = new Box<>();
System.out.println(stringBox.getClass() == integerBox.getClass()); // 输出: true
运行时，Box<String> 和 Box<Integer> 的类型都是 Box，因为类型参数 T 被擦除为 Object。这意味着泛型主要在编译时提供类型检查，而非运行时。
2.2 类型边界的引入
为了限制类型参数的范围，Java提供了边界（Bounds）：
- 上界（Upper Bound）：
T extends SomeClass，表示T必须是SomeClass或其子类。 - 下界（Lower Bound）：
T super SomeClass，表示T必须是SomeClass或其父类。
示例：
public class Box<T extends Number> {
private T content;
public void setContent(T content) {
this.content = content;
}
public T getContent() {
return content;
}
}
public static void main(String[] args) {
Box<Integer> integerBox = new Box<>();
integerBox.setContent(10);
System.out.println(integerBox.getContent()); // 输出: 10
// Box<String> stringBox = new Box<>(); // 编译错误，String 不是 Number 的子类
}
这里，T 被限制为 Number 或其子类（如 Integer、Double），提高了类型安全性。
3. 泛型的高级用法
3.1 通配符（Wildcard）
通配符 ? 用于表示未知类型，常用于方法参数：
?：无界通配符，表示任何类型。? extends SomeClass：上界通配符，表示SomeClass或其子类。? super SomeClass：下界通配符，表示SomeClass或其父类。
示例：
public void printList(List<?> list) {
for (Object elem : list) {
System.out.println(elem);
}
}
public static void main(String[] args) {
List<String> stringList = Arrays.asList("a", "b", "c");
List<Integer> integerList = Arrays.asList(1, 2, 3);
printList(stringList); // 输出: a b c
printList(integerList); // 输出: 1 2 3
}
这个方法可以接受任何类型的 List，展示了通配符的灵活性。
3.2 泛型与继承
泛型类型之间没有直接的继承关系。例如：
List<String> stringList = new ArrayList<>();
// List<Object> objectList = stringList; // 编译错误
解决方法是使用通配符：
List<? extends Object> objectList = stringList; // 正确
3.3 泛型与数组
由于类型擦除，Java不允许直接创建泛型数组：
// T[] array = new T[10]; // 编译错误
解决方法是使用 Object 数组并进行类型转换：
public class GenericArray<T> {
private T[] array;
@SuppressWarnings("unchecked")
public GenericArray(int size) {
array = (T[]) new Object[size]; // 类型转换
}
public void set(int index, T value) {
array[index] = value;
}
public T get(int index) {
return array[index];
}
}
public static void main(String[] args) {
GenericArray<String> ga = new GenericArray<>(3);
ga.set(0, "Hello");
System.out.println(ga.get(0)); // 输出: Hello
}
4. 泛型的应用场景
4.1 集合框架
Java集合框架（如 List<T>、Set<T>、Map<K, V>）广泛使用泛型：
List<String> stringList = new ArrayList<>();
stringList.add("Hello");
String s = stringList.get(0); // 无需类型转换
System.out.println(s); // 输出: Hello
泛型确保集合只存储指定类型的元素，避免类型错误。
4.2 自定义容器类
泛型可用于设计通用的容器类。例如，一个键值对类：
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;
}
}
public static void main(String[] args) {
Pair<String, Integer> pair = new Pair<>("Age", 25);
System.out.println(pair.getKey() + ": " + pair.getValue()); // 输出: Age: 25
}
4.3 泛型算法
泛型可用于编写通用算法。例如，比较两个元素的最大值：
public <T extends Comparable<T>> T max(T a, T b) {
return a.compareTo(b) > 0 ? a : b;
}
public static void main(String[] args) {
System.out.println(max(5, 3)); // 输出: 5
System.out.println(max("a", "b")); // 输出: b
}
这个方法适用于任何实现了 Comparable 接口的类型。
5. 泛型的注意事项
- 基本类型不可用：泛型参数必须是引用类型，不能是基本类型（如
int），需使用包装类（如Integer）。 - 静态上下文限制：类的类型参数不能用于静态字段或方法。
- 异常类限制：Java不允许定义泛型异常类。
6. 总结
Java泛型通过类型参数提供了类型安全和代码重用的能力。其核心原理是类型擦除，在编译时进行类型检查。通过泛型类、方法、通配符等特性，开发者可以在集合框架、自定义容器和通用算法中灵活应用泛型。掌握这些原理和方法，能显著提升代码的质量和可维护性。