Java中的泛型（Generics）是一个强大且灵活的特性，它允许程序员编写可以与多种数据类型一起工作的代码，而无需在编译时指定具体的类型。泛型的使用可以显著提高代码的可读性、安全性和重用性。本文将深入解析Java中的泛型，并通过代码示例展示其具体应用。
一、泛型概述
泛型，即"参数化类型"。在Java中，泛型允许在编译时定义类型参数化的类、接口或方法，这意味着它们可以在多种数据类型上工作，而不是只针对特定数据类型。通过使用泛型，程序员可以在编译时捕获许多常见的类型错误，从而提供更好的类型安全。
二、泛型的基本原理
1. 泛型类和泛型方法
在Java中，泛型类和泛型方法允许在类名或方法名后面的尖括号<>中声明类型参数。这些类型参数在类或方法的实现中被用作占位符，以表示实际的数据类型。
泛型类示例：
java
public class Box<T> {
private T content;
public Box(T content) {
this.content = content;
}
public T getContent() {
return content;
}
}在这个示例中，Box类是一个泛型类，它有一个类型参数T。这意味着Box类可以存储任何类型的数据。
泛型方法示例：
java
public class GenericExample {
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.print(element + " ");
}
System.out.println();
}
public static void main(String[] args) {
Integer[] intArray = {1, 2, 3, 4, 5};
String[] strArray = {"apple", "banana", "orange"};
printArray(intArray);
printArray(strArray);
}
}在这个示例中，printArray方法是一个泛型方法，它可以打印任何类型的数组。
2. 泛型通配符
通配符（?）在Java泛型中用于表示未知类型。通配符可以用在泛型类、方法和接口中，以表示可以接受任何类型的数据。
使用通配符的示例：
java
public class Info<T> {
private T var;
public void setVar(T var) {
this.var = var;
}
public T getVar() {
return this.var;
}
public String toString() {
return this.var.toString();
}
}
public class GenericsDemo14 {
public static void main(String args[]) {
Info<String> i = new Info<String>();
i.setVar("it");
fun(i);
}
public static void fun(Info<?> temp) {
System.out.println("内容: " + temp);
}
}在这个示例中，fun方法接受一个Info<?>类型的参数，其中?表示Info对象可以存储任何类型的数据。
3. 泛型边界
使用extends和super关键字来限制可能的类型。这被称为泛型边界（Bounds）。
泛型边界示例：
java
public class LoggedList<T extends Comparable<T>> {
// 类的实现
}在这个示例中，LoggedList类接受一个类型参数T，它必须是Comparable的子类。这意味着LoggedList类只能存储可以比较的元素。
三、泛型的高级特性
1. 泛型类和接口的继承与实现
泛型类可以扩展其他类或实现接口，需要在子类或实现类中指定具体的类型参数。子类或实现类可以保留父类或接口的泛型类型，也可以重新指定类型参数。
泛型类继承示例：
java
public class Animal<T> {
private T data;
public Animal(T data) {
this.data = data;
}
public T getData() {
return data;
}
}
public class Dog<T> extends Animal<T> {
public Dog(T data) {
super(data);
}
public void bark() {
System.out.println("Woof");
}
}在这个示例中，Dog类继承自Animal类，并保留了Animal类的泛型类型T。
2. 泛型方法的重载
Java允许重载泛型方法，即同一个类中可以有多个泛型方法，只要它们的参数列表不同即可。
泛型方法重载示例：
java
public class GenericOverload {
public <T> void printArray(T[] array) {
for (T element : array) {
System.out.print(element + " ");
}
System.out.println();
}
public <T> void printArray(T[] array, String separator) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]);
if (i < array.length - 1) {
System.out.print(separator);
}
}
System.out.println();
}
public static void main(String[] args) {
GenericOverload go = new GenericOverload();
Integer[] intArray = {1, 2, 3, 4, 5};
String[] strArray = {"apple", "banana", "orange"};
go.printArray(intArray);
go.printArray(strArray, ", ");
}
}在这个示例中，printArray方法被重载了两次，一次不接受分隔符，另一次接受一个分隔符作为参数。
3. 泛型擦除
Java中的泛型是通过类型擦除来实现的。在编译时，编译器会擦除泛型类型信息，将泛型转换为原始类型。泛型类型参数会被替换为其上界，如果没有指定上界，则会替换为Object。
泛型擦除示例：
java
public class GenericErasure {
public static void main(String[] args) {
List<String> stringList = new ArrayList<>();
List<Integer> integerList = new ArrayList<>();
Class<?> stringListClass = stringList.getClass();
Class<?> integerListClass = integerList.getClass();
System.out.println(stringListClass == integerListClass); // 输出: true
}
}在这个示例中，尽管stringList和integerList在编译时有不同的泛型类型，但在运行时它们的类类型是相同的，都是ArrayList。
四、泛型的应用场景
以下是几个泛型在不同场景中的应用示例：
1. 泛型集合
在Java中，集合框架广泛使用泛型来存储不同类型的对象，而不需要进行强制类型转换。
java
import java.util.ArrayList;
import java.util.List;
public class GenericCollectionExample {
public static void main(String[] args) {
// 创建一个存储字符串的ArrayList
List<String> stringList = new ArrayList<>();
stringList.add("Hello");
stringList.add("World");
// 遍历并打印字符串列表
for (String str : stringList) {
System.out.println(str);
}
// 创建一个存储整数的ArrayList
List<Integer> integerList = new ArrayList<>();
integerList.add(1);
integerList.add(2);
// 遍历并打印整数列表
for (Integer num : integerList) {
System.out.println(num);
}
}
}2. 泛型方法
泛型方法允许方法操作参数化类型，使得方法可以处理不同类型的输入。
java
public class GenericMethodExample {
// 定义一个泛型方法来打印任意类型的数组元素
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.print(element + " ");
}
System.out.println();
}
public static void main(String[] args) {
Integer[] intArray = {1, 2, 3, 4, 5};
Double[] doubleArray = {1.1, 2.2, 3.3, 4.4, 5.5};
Character[] charArray = {'H', 'E', 'L', 'L', 'O'};
// 使用泛型方法打印数组
printArray(intArray);
printArray(doubleArray);
printArray(charArray);
}
}3. 泛型类
泛型类使得类的实例可以作用于不同的数据类型。
java
public class GenericBox<T> {
private T item;
// 构造函数
public GenericBox(T item) {
this.item = item;
}
// Getter方法
public T getItem() {
return item;
}
// Setter方法
public void setItem(T item) {
this.item = item;
}
public static void main(String[] args) {
// 创建一个存储字符串的GenericBox实例
GenericBox<String> stringBox = new GenericBox<>("Hello World");
System.out.println(stringBox.getItem());
// 创建一个存储整数的GenericBox实例
GenericBox<Integer> integerBox = new GenericBox<>(123);
System.out.println(integerBox.getItem());
}
}4. 泛型接口
泛型接口使得实现类可以处理不同的数据类型。
java
public interface GenericInterface<T> {
void performAction(T t);
}
public class GenericInterfaceImpl<T> implements GenericInterface<T> {
@Override
public void performAction(T t) {
System.out.println("Performing action with: " + t);
}
public static void main(String[] args) {
// 使用字符串实现泛型接口
GenericInterface<String> stringAction = new GenericInterfaceImpl<>();
stringAction.performAction("Hello");
// 使用整数实现泛型接口
GenericInterface<Integer> integerAction = new GenericInterfaceImpl<>();
integerAction.performAction(10);
}
}这些示例展示了泛型在Java编程中的广泛应用，从集合、方法到类和接口，泛型都提供了强大的类型安全性和灵活性。