Java 泛型（Generics）是 Java 语言在 JDK 5 中引入的一项强大的特性，它允许类、接口和方法使用类型参数。泛型的主要目的是提高代码的重用性、类型安全性和可读性。本文将深入探讨 Java 泛型的各个方面，介绍其背景、优势、适用场景、实现方式和底层原理，并结合大量示例代码进行详细说明。

背景与初衷

在 Java 泛型引入之前，开发者经常使用 Object 类型来实现通用的数据结构和方法。这种做法虽然灵活，但存在类型安全问题，因为类型转换是在运行时进行的，容易导致 ClassCastException 异常。同时，这种代码的可读性和可维护性较差。

为了提高代码的类型安全性和重用性，Java 在 JDK 5 中引入了泛型。泛型允许开发者在编写类、接口和方法时使用类型参数，从而避免了类型转换的麻烦，并使代码更具可读性和可维护性。

优势和劣势

优势

  1. 类型安全：泛型在编译时进行类型检查，避免了运行时的 ClassCastException 异常。
  2. 代码重用：泛型允许编写更通用的代码，提高了代码的重用性。
  3. 可读性和可维护性：泛型使代码更加清晰，容易理解和维护。

劣势

  1. 复杂性：泛型的语法和概念对于初学者来说较为复杂，学习曲线较陡。
  2. 类型擦除：Java 泛型在运行时会进行类型擦除，可能导致某些情况下无法获取泛型类型的信息。
  3. 性能开销：虽然泛型在编译时进行类型检查，但在某些情况下可能会引入额外的性能开销。

适用场景

业务场景

  1. 数据结构：如集合类 ArrayList、HashMap 等，通过泛型实现数据结构的通用性和类型安全。
  2. 服务层：在业务服务层使用泛型，实现通用的服务方法，如分页查询、数据转换等。
  3. 工具类：编写通用的工具类和方法，提高代码的重用性和可维护性。

技术场景

  1. 框架开发：在开发框架时使用泛型，实现通用的框架组件，如依赖注入、数据访问层等。
  2. 库开发：在开发公共库时使用泛型，提高库的通用性和可扩展性。
  3. API 设计：在设计 API 时使用泛型，提高 API 的灵活性和类型安全。

泛型的组成部分和关键点

泛型类

泛型类是包含一个或多个类型参数的类。类型参数在类声明中使用尖括号 <T> 指定，T 是类型参数的名称，可以是任意合法的标识符。

  1. public class GenericClass<T> {
  2.     private T data;
  4.     public GenericClass(T data) {
  5.         this.data = data;
  6.     }
  8.     public T getData() {
  9.         return data;
  10.     }
  12.     public void setData(T data) {
  13.         this.data = data;
  14.     }
  16.     public static void main(String[] args) {
  17.         GenericClass<String> stringInstance = new GenericClass<>("Hello, Generics");
  18.         System.out.println(stringInstance.getData());
  20.         GenericClass<Integer> integerInstance = new GenericClass<>(42);
  21.         System.out.println(integerInstance.getData());
  22.     }
  23. }

泛型接口

泛型接口是包含类型参数的接口。与泛型类类似，类型参数在接口声明中使用尖括号 <T> 指定。

  1. public interface GenericInterface<T> {
  2.     T getData();
  3.     void setData(T data);
  4. }
  6. public class GenericInterfaceImpl<T> implements GenericInterface<T> {
  7.     private T data;
  9.     @Override
  10.     public T getData() {
  11.         return data;
  12.     }
  14.     @Override
  15.     public void setData(T data) {
  16.         this.data = data;
  17.     }
  19.     public static void main(String[] args) {
  20.         GenericInterface<String> stringInstance = new GenericInterfaceImpl<>();
  21.         stringInstance.setData("Hello, Generics Interface");
  22.         System.out.println(stringInstance.getData());
  23.     }
  24. }

泛型方法

泛型方法是包含类型参数的方法。类型参数在方法声明中使用尖括号 <T> 指定，并放在方法返回类型之前。

  1. public class GenericMethod {
  2.     public <T> void printArray(T[] array) {
  3.         for (T element : array) {
  4.             System.out.print(element + " ");
  5.         }
  6.         System.out.println();
  7.     }
  9.     public static void main(String[] args) {
  10.         GenericMethod gm = new GenericMethod();
  11.         Integer[] intArray = {1, 2, 3, 4, 5};
  12.         String[] stringArray = {"A", "B", "C", "D"};
  14.         gm.printArray(intArray);
  15.         gm.printArray(stringArray);
  16.     }
  17. }

泛型类型参数的边界

在某些情况下，可能需要限制类型参数的范围。通过使用 extends 关键字，可以指定类型参数的上边界；通过使用 super 关键字，可以指定类型参数的下边界。

上边界
  1. public class BoundedTypeParameter<T extends Number> {
  2.     private T data;
  4.     public BoundedTypeParameter(T data) {
  5.         this.data = data;
  6.     }
  8.     public T getData() {
  9.         return data;
  10.     }
  12.     public static void main(String[] args) {
  13.         BoundedTypeParameter<Integer> intInstance = new BoundedTypeParameter<>(123);
  14.         System.out.println(intInstance.getData());
  16.         BoundedTypeParameter<Double> doubleInstance = new BoundedTypeParameter<>(45.67);
  17.         System.out.println(doubleInstance.getData());
  18.     }
  19. }
下边界
  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class LowerBoundWildcard {
  5.     public static void addNumbers(List<? super Integer> list) {
  6.         list.add(1);
  7.         list.add(2);
  8.         list.add(3);
  9.     }
  11.     public static void main(String[] args) {
  12.         List<Number> numberList = new ArrayList<>();
  13.         addNumbers(numberList);
  14.         System.out.println(numberList);
  15.     }
  16. }

泛型中的通配符

通配符用于在类型参数未知的情况下表示泛型类型。通配符有三种类型：无界通配符、有界通配符（上边界）和有界通配符（下边界）。

无界通配符

无界通配符使用 ? 表示，可以匹配任何类型。

  1. import java.util.List;
  3. public class UnboundedWildcard {
  4.     public static void printList(List<?> list) {
  5.         for (Object element : list) {
  6.             System.out.print(element + " ");
  7.         }
  8.         System.out.println();
  9.     }
  11.     public static void main(String[] args) {
  12.         List<Integer> intList = List.of(1, 2, 3);
  13.         List<String> stringList = List.of("A", "B", "C");
  15.         printList(intList);
  16.         printList(stringList);
  17.     }
  18. }

有界通配符（上边界）

有界通配符使用 ? extends Type 表示，可以匹配指定类型及其子类型。

  1. import java.util.List;
  3. public class UpperBoundedWildcard {
  4.     public static double sumOfNumbers(List<? extends Number> list) {
  5.         double sum = 0.0;
  6.         for (Number number : list) {
  7.             sum += number.doubleValue();
  8.         }
  9.         return sum;
  10.     }
  12.     public static void main(String[] args) {
  13.         List<Integer> intList = List.of(1, 2, 3);
  14.         List<Double> doubleList = List.of(1.1, 2.2, 3.3);
  16.         System.out.println("Sum of intList: " + sumOfNumbers(intList));
  17.         System.out.println("Sum of doubleList: " + sumOfNumbers(doubleList));
  18.     }
  19. }

有界通配符（下边界）

有界通配符使用 ? super Type 表示，可以匹配指定类型及其父类型。

  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class LowerBoundedWildcard {
  5.     public static void addIntegers(List<? super Integer> list) {
  6.         list.add(1);
  7.         list.add(2);
  8.         list.add(3);
  9.     }
  11.     public static void main(String[] args) {
  12.         List<Number> numberList = new ArrayList<>();
  13.         addIntegers(numberList);
  14.         System.out.println(numberList);
  15.     }
  16. }

泛型的底层原理和实现

类型擦除

Java 泛型在编译时会进行类型擦除，这意味着在运行时，泛型类型参数被移除，所有的类型参数被替换为其边界类型（如果没有指定边界类型，则替换为 Object）。这使得 Java 泛型与之前的版本兼容，但也带来了一些限制。

  1. public class TypeErasure<T
  3. > {
  4.     private T data;
  6.     public TypeErasure(T data) {
  7.         this.data = data;
  8.     }
  10.     public T getData() {
  11.         return data;
  12.     }
  14.     public static void main(String[] args) {
  15.         TypeErasure<String> stringInstance = new TypeErasure<>("Hello");
  16.         System.out.println(stringInstance.getData());
  18.         TypeErasure<Integer> integerInstance = new TypeErasure<>(123);
  19.         System.out.println(integerInstance.getData());
  20.     }
  21. }

编译后，TypeErasure 类的字节码中，类型参数 T 会被替换为 Object，并进行必要的类型转换。

桥方法

由于类型擦除的存在，编译器在某些情况下会生成桥方法以确保类型安全。例如，当泛型类实现了一个泛型接口且泛型类型参数不同步时，会生成桥方法。

  1. public class BridgeMethodExample implements Comparable<BridgeMethodExample> {
  2.     private int value;
  4.     public BridgeMethodExample(int value) {
  5.         this.value = value;
  6.     }
  8.     @Override
  9.     public int compareTo(BridgeMethodExample other) {
  10.         return Integer.compare(this.value, other.value);
  11.     }
  13.     public static void main(String[] args) {
  14.         BridgeMethodExample example1 = new BridgeMethodExample(1);
  15.         BridgeMethodExample example2 = new BridgeMethodExample(2);
  16.         System.out.println(example1.compareTo(example2));
  17.     }
  18. }

编译后，compareTo 方法会生成一个桥方法，以确保 Comparable 接口的类型参数兼容。

泛型的高级用法

泛型数组

由于类型擦除的限制，不能直接创建泛型数组，但可以通过创建数组的通用类来实现泛型数组。

  1. public class GenericArray<T> {
  2.     private T[] array;
  4.     @SuppressWarnings("unchecked")
  5.     public GenericArray(int size) {
  6.         array = (T[]) new Object[size];
  7.     }
  9.     public T get(int index) {
  10.         return array[index];
  11.     }
  13.     public void set(int index, T value) {
  14.         array[index] = value;
  15.     }
  17.     public static void main(String[] args) {
  18.         GenericArray<String> stringArray = new GenericArray<>(10);
  19.         stringArray.set(0, "Hello");
  20.         System.out.println(stringArray.get(0));
  21.     }
  22. }

泛型方法中的多重限定

可以在泛型方法中对类型参数进行多重限定，以确保类型参数满足多个条件。

  1. public class MultiBoundedTypeParameter {
  2.     public static <T extends Number & Comparable<T>> T max(T a, T b) {
  3.         return a.compareTo(b) > 0 ? a : b;
  4.     }
  6.     public static void main(String[] args) {
  7.         System.out.println(max(3, 4));
  8.         System.out.println(max(3.5, 2.7));
  9.     }
  10. }

泛型的限制和注意事项

不能在静态上下文中使用泛型类型参数

由于类型参数在运行时被擦除，不能在静态上下文中使用泛型类型参数。

  1. public class StaticGenericMethod<T> {
  2.     private T data;
  4.     public StaticGenericMethod(T data) {
  5.         this.data = data;
  6.     }
  8.     // 不能在静态方法中使用泛型类型参数
  9.     // public static T getStaticData() {
  10.     //     return data;
  11.     // }
  13.     public T getData() {
  14.         return data;
  15.     }
  17.     public static void main(String[] args) {
  18.         StaticGenericMethod<String> instance = new StaticGenericMethod<>("Hello");
  19.         System.out.println(instance.getData());
  20.     }
  21. }

不能创建泛型类型的实例

由于类型擦除的存在，不能直接创建泛型类型的实例，但可以通过反射来创建实例。

  1. public class GenericInstance<T> {
  2.     private Class<T> type;
  4.     public GenericInstance(Class<T> type) {
  5.         this.type = type;
  6.     }
  8.     public T createInstance() throws IllegalAccessException, InstantiationException {
  9.         return type.newInstance();
  10.     }
  12.     public static void main(String[] args) throws IllegalAccessException, InstantiationException {
  13.         GenericInstance<String> instance = new GenericInstance<>(String.class);
  14.         String str = instance.createInstance();
  15.         System.out.println(str);
  16.     }
  17. }

泛型类型参数不能用于异常处理

由于类型擦除的存在，不能在异常处理的 catch 块中使用泛型类型参数。

  1. public class GenericException<T extends Exception> {
  2.     private T exception;
  4.     public GenericException(T exception) {
  5.         this.exception = exception;
  6.     }
  8.     public void throwException() throws T {
  9.         throw exception;
  10.     }
  12.     // 不能在 catch 块中使用泛型类型参数
  13.     // public void handleException() {
  14.     //     try {
  15.     //         throwException();
  16.     //     } catch (T e) {
  17.     //         e.printStackTrace();
  18.     //     }
  19.     // }
  21.     public static void main(String[] args) {
  22.         GenericException<RuntimeException> instance = new GenericException<>(new RuntimeException("Generic Exception"));
  23.         try {
  24.             instance.throwException();
  25.         } catch (RuntimeException e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  29. }

泛型在 Java 标准库中的应用

集合框架

Java 集合框架广泛使用了泛型，以提供类型安全的集合类。

  1. import java.util.ArrayList;
  2. import java.util.HashMap;
  3. import java.util.List;
  4. import java.util.Map;
  6. public class CollectionsExample {
  7.     public static void main(String[] args) {
  8.         List<String> stringList = new ArrayList<>();
  9.         stringList.add("Hello");
  10.         stringList.add("Generics");
  11.         System.out.println(stringList);
  13.         Map<String, Integer> map = new HashMap<>();
  14.         map.put("One", 1);
  15.         map.put("Two", 2);
  16.         System.out.println(map);
  17.     }
  18. }

Optional 类

Optional 类使用泛型表示可能存在也可能不存在的值，从而避免了空指针异常。

  1. import java.util.Optional;
  3. public class OptionalExample {
  4.     public static void main(String[] args) {
  5.         Optional<String> optional = Optional.of("Hello, Generics");
  6.         optional.ifPresent(System.out::println);
  8.         Optional<String> emptyOptional = Optional.empty();
  9.         System.out.println(emptyOptional.orElse("Default Value"));
  10.     }
  11. }

Stream API

Stream API 使用泛型提供了强大的数据处理功能。

  1. import java.util.Arrays;
  2. import java.util.List;
  3. import java.util.stream.Collectors;
  5. public class StreamExample {
  6.     public static void main(String[] args) {
  7.         List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
  9.         List<Integer> evenNumbers = numbers.stream()
  10.                                            .filter(n -> n % 2 == 0)
  11.                                            .collect(Collectors.toList());
  13.         System.out.println(evenNumbers);
  14.     }
  15. }

泛型与反射的结合

泛型和反射的结合使得开发者可以在运行时获取泛型类型的信息，从而实现更加灵活和通用的代码。

  1. import java.lang.reflect.ParameterizedType;
  2. import java.lang.reflect.Type;
  4. public class GenericReflection<T> {
  5.     private T data;
  7.     public GenericReflection(T data) {
  8.         this.data = data;
  9.     }
  11.     public void printGenericType() {
  12.         Type superClass = getClass().getGenericSuperclass();
  13.         if (superClass instanceof ParameterizedType) {
  14.             ParameterizedType parameterizedType = (ParameterizedType) superClass;
  15.             Type[] typeArguments = parameterizedType.getActualTypeArguments();
  16.             for (Type type : typeArguments) {
  17.                 System.out.println("Type argument: " + type.getTypeName());
  18.             }
  19.         }
  20.     }
  22.     public static void main(String[] args) {
  23.         GenericReflection<String> instance = new GenericReflection<>("Hello, Generics");
  24.         instance.printGenericType();
  25.     }
  26. }

泛型在常见设计模式中的应用

工厂模式

泛型可以用于实现通用的工厂模式，从而创建不同类型的对象。

  1. public interface Factory<T> {
  2.     T create();
  3. }
  5. public class CarFactory implements Factory<Car> {
  6.     @Override
  7.     public Car create() {
  8.         return new Car();
  9.     }
  10. }
  12. public class Car {
  13.     private String model;
  15.     public Car() {
  16.         this.model = "Default Model";
  17.     }
  19.     @Override
  20.     public String toString() {
  21.         return "Car{model='" + model + "'}";
  22.     }
  23. }
  25. public class FactoryExample {
  26.     public static void main(String[] args) {
  27.         Factory<Car> carFactory = new CarFactory();
  28.         Car car = carFactory.create();
  29.         System.out.println(car);
  30.     }
  31. }

单例模式

泛型可以用于实现通用的单例模式，从而管理不同类型的单例对象。

  1. public class Singleton<T> {
  2.     private static Singleton instance;
  3.     private T data;
  5.     private Singleton() {}
  7.     public static synchronized <T> Singleton<T> getInstance() {
  8.         if (instance == null) {
  9.             instance = new Singleton<>();
  10.         }
  11.         return instance;
  12.     }
  14.     public T getData() {
  15.         return data;
  16.     }
  18.     public void setData(T data) {
  19.         this.data = data;
  20.     }
  22.     public static void main(String[] args) {
  23.         Singleton<String> stringSingleton = Singleton.getInstance();
  24.         stringSingleton.setData("Hello, Singleton");
  25.         System.out.println(stringSingleton.getData());
  27.         Singleton<Integer>
  29.  integerSingleton = Singleton.getInstance();
  30.         integerSingleton.setData(42);
  31.         System.out.println(integerSingleton.getData());
  32.     }
  33. }

总结

Java 泛型是一项强大的特性，它通过引入类型参数来提高代码的类型安全性、重用性和可读性。本文详细介绍了泛型的背景、优势、适用场景、实现方式和底层原理，并结合大量示例代码说明了泛型的各种用法。同时，本文还探讨了泛型在 Java 标准库中的应用、泛型与反射的结合以及泛型在常见设计模式中的应用。