Java泛型是一个强大的编程特性，它可以在代码中提供类型安全和可重用性。本文介绍了Java泛型的原理、实践以及一些常见的陷阱。
1. 泛型的原理
Java泛型是在编译时期进行类型检查的机制。它通过参数化类型的方式，使得代码可以适用于多种类型，从而提高代码的可复用性和类型安全性。
编译时，Java泛型会擦除类型概念，并将泛型类或方法转化为原始类型。因此，泛型类型的参数在运行时是不可知的。但是，编译器会将插入适当的转换代码来保证类型的安全性。
2. 泛型的实践
2.1 泛型类
定义一个泛型类可以通过在类名后面添加尖括号和参数列表来实现。例如，class MyClass<T>。其中，T是一个类型参数，可以在类中的方法中使用。
class MyClass<T> {
private T data;
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
使用泛型类时，可以通过定义类型参数来指定具体的类型。
MyClass<Integer> myObj = new MyClass<>();
myObj.setData(5);
Integer value = myObj.getData(); // value = 5
2.2 泛型方法
除了定义泛型类，还可以在方法中使用泛型。定义泛型方法需要在返回类型之前添加类型参数。
class Utils {
public static <T> T getMax(T[] array) {
T max = array[0];
for (T element : array) {
if (element.compareTo(max) > 0) {
max = element;
}
}
return max;
}
}
使用泛型方法时，可以根据方法参数的类型来推断类型参数。例如：
Integer[] ints = {1, 2, 3, 4, 5};
Integer maxInt = Utils.getMax(ints); // maxInt = 5
String[] strs = {"apple", "banana", "orange"};
String maxStr = Utils.getMax(strs); // maxStr = "orange"
2.3 通配符
通配符允许我们在使用泛型类型时灵活地指定类型范围。在方法参数中使用通配符时，我们可以传入任何类型的泛型对象。
class Printer {
public static void printList(List<?> list) {
for (Object element : list) {
System.out.println(element);
}
}
}
在上面的例子中，<?> 表示任意类型。可以使用? extends className表示某个类的子类，或者使用? super className表示某个类的父类。
使用通配符时需要注意的是，不能往一个带有通配符类型的集合中添加元素。但是可以读取集合中的元素。
List<?> list = new ArrayList<>();
list.add(10); // 编译错误
Integer item = list.get(0); // 正确
2.4 类型边界
类型边界允许我们限制泛型类型的范围。使用类型边界时，需要在类型参数后面添加关键字extends或super。
例如：
class MathUtils {
public static <T extends Number> double average(T[] array) {
double sum = 0.0;
for (T element : array) {
sum += element.doubleValue();
}
return sum / array.length;
}
}
在上面的例子中，<T extends Number> 表示T必须是Number类的子类。
Integer[] ints = {1, 2, 3, 4, 5};
double avg = MathUtils.average(ints); // avg = 3.0
String[] strs = {"1", "2", "3", "4", "5"};
double avg2 = MathUtils.average(strs); // 编译错误
3. 泛型的陷阱
虽然泛型是一个非常有用的特性，但是在使用过程中也存在一些陷阱需要注意。
3.1 泛型类型擦除
由于Java泛型是在编译时进行类型检查的，因此在运行时无法获取泛型的类型信息。这就意味着无法在运行时使用泛型类型参数的特定方法。
class MyClass<T> {
public void printType() {
System.out.println(T.class.getName()); // 编译错误
}
}
当使用泛型时，注意在运行时需要自己保证类型的合法性。
3.2 泛型数组
Java不允许创建具有参数化类型的数组。以下代码会导致编译错误。
List<Integer>[] array = new List<Integer>[10]; // 编译错误
如果需要创建一个泛型数组，可以使用通配符来处理。
List<?>[] array = new List<?>[10]; // 正确
3.3 类型擦除的影响
由于Java泛型的类型擦除特性，类型参数没有在运行时保留，因此可能会导致一些意外的行为。
class MyClass<T> {
private T data;
public void setData(T data) {
this.data = data;
}
public T getData() {
return data;
}
}
MyClass<String> myObj = new MyClass<>();
myObj.setData("Hello");
String data = myObj.getData(); // data = "Hello"
myObj.setData(10); // 编译器不会报错，但在运行时会抛出类型转换异常
在上面的例子中，由于类型擦除，setData()方法允许接收任何类型的参数。编译器不会报错，但是在运行时会抛出类型转换异常。
结论
Java泛型是一种强大的编程特性，可以提高代码的可复用性和类型安全性。在实践中，我们可以使用泛型类、泛型方法、通配符和类型边界来处理不同的场景。然而，在使用泛型时也需要注意一些陷阱，如类型擦除、泛型数组和类型转换异常。通过了解这些特性和注意事项，我们可以更好地运用泛型编程。
本文来自极简博客，作者：时光静好，转载请注明原文链接：Java泛型编程：原理、实践与陷阱
