【Java基础-46.1】Java中创建自定义泛型类及其应用

泛型（Generics）是 Java 语言中一项强大的特性，它允许开发者在编写代码时使用类型参数，从而提高代码的复用性和类型安全性。通过泛型，我们可以创建适用于多种数据类型的类、接口和方法，而不必为每种数据类型编写重复的代码。本文将详细介绍如何在 Java 中创建自定义泛型类，并探讨其在实际开发中的应用。

1. 什么是泛型？

泛型是 Java 5 引入的一项特性，它允许在定义类、接口和方法时使用类型参数。这些类型参数在实例化时被具体的类型替换，从而使代码更加通用和类型安全。

例如，Java 集合框架中的 ArrayList 就是一个泛型类，我们可以通过指定类型参数来创建一个存储特定类型元素的列表：

ArrayList<String> list = new ArrayList<>();

在这个例子中，String 是类型参数，它指定了 ArrayList 中存储的元素类型。

2. 创建自定义泛型类 2.1 基本语法

要创建一个自定义泛型类，我们需要在类名后面使用尖括号 < > 来声明类型参数。类型参数可以是任何标识符，通常使用单个大写字母来表示，例如 T、E、K、V 等。

下面是一个简单的自定义泛型类的例子：

public class Box<T> { private T content; public void setContent(T content) { this.content = content; } public T getContent() { return content; } }

在这个例子中，Box 类有一个类型参数 T，它表示 Box 中存储的内容的类型。T 可以是任何类型，例如 String、Integer 或自定义类。

2.2 使用自定义泛型类

我们可以通过指定具体的类型来实例化泛型类。例如：

Box<String> stringBox = new Box<>(); stringBox.setContent("Hello, Generics!"); System.out.println(stringBox.getContent()); // 输出: Hello, Generics! Box<Integer> integerBox = new Box<>(); integerBox.setContent(123); System.out.println(integerBox.getContent()); // 输出: 123

在这个例子中，我们创建了两个 Box 对象，一个用于存储 String 类型的数据，另一个用于存储 Integer 类型的数据。

2.3 多个类型参数

泛型类可以有多个类型参数。例如，我们可以创建一个 Pair 类，用于存储两个不同类型的值：

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; } }

使用 Pair 类的例子：

Pair<String, Integer> pair = new Pair<>("Age", 25); System.out.println("Key: " + pair.getKey() + ", Value: " + pair.getValue()); // 输出: Key: Age, Value: 25 3. 泛型的类型擦除

Java 的泛型是通过类型擦除（Type Erasure）来实现的。这意味着在编译时，所有的泛型类型信息都会被擦除，替换为它们的原始类型（通常是 Object）。因此，在运行时，泛型类的实例并不知道它们的类型参数。

例如，以下代码在编译后会被转换为使用 Object 类型：

Box<String> stringBox = new Box<>(); stringBox.setContent("Hello");

编译后的代码类似于：

Box stringBox = new Box(); stringBox.setContent((Object) "Hello");

由于类型擦除的存在，我们不能在运行时获取泛型类的类型参数。例如，以下代码是无法通过编译的：

public class Box<T> { public void printType() { System.out.println(T.class); // 错误: 无法获取 T 的类信息 } } 4. 泛型的应用场景 4.1 集合框架

Java 集合框架是泛型应用最广泛的领域之一。通过泛型，我们可以创建类型安全的集合，避免在运行时出现类型转换错误。

例如：

List<String> names = new ArrayList<>(); names.add("Alice"); names.add("Bob"); // names.add(123); // 编译错误: 无法将 Integer 类型添加到 String 类型的列表中 4.2 自定义数据结构

泛型可以用于创建自定义的数据结构，例如栈、队列、链表等。通过泛型，这些数据结构可以适用于任何类型的数据。

例如，一个简单的泛型栈实现：

public class Stack<T> { private List<T> elements = new ArrayList<>(); public void push(T element) { elements.add(element); } public T pop() { if (elements.isEmpty()) { throw new IllegalStateException("Stack is empty"); } return elements.remove(elements.size() - 1); } public boolean isEmpty() { return elements.isEmpty(); } }

使用 Stack 类的例子：

Stack<Integer> stack = new Stack<>(); stack.push(1); stack.push(2); System.out.println(stack.pop()); // 输出: 2 System.out.println(stack.pop()); // 输出: 1 4.3 泛型方法

除了泛型类，我们还可以创建泛型方法。泛型方法允许在方法级别使用类型参数，从而使方法更加通用。

例如：

public class Utils { public static <T> T getFirstElement(List<T> list) { if (list.isEmpty()) { throw new IllegalStateException("List is empty"); } return list.get(0); } }

使用泛型方法的例子：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); String firstName = Utils.getFirstElement(names); System.out.println(firstName); // 输出: Alice List<Integer> numbers = Arrays.asList(1, 2, 3); Integer firstNumber = Utils.getFirstElement(numbers); System.out.println(firstNumber); // 输出: 1 5. 泛型的限制 5.1 不能使用基本类型

泛型的类型参数必须是引用类型，不能是基本类型（如 int、char 等）。如果需要使用基本类型，可以使用对应的包装类（如 Integer、Character 等）。

例如，以下代码是错误的：

Box<int> intBox = new Box<>(); // 错误: 不能使用基本类型

正确的做法是使用包装类：

Box<Integer> intBox = new Box<>(); 5.2 不能创建泛型数组

由于类型擦除的存在，Java 不允许创建泛型数组。例如，以下代码是无法通过编译的：

Box<String>[] boxes = new Box<String>[10]; // 错误: 不能创建泛型数组 5.3 不能实例化类型参数

由于类型擦除，我们不能直接实例化类型参数。例如，以下代码是错误的：

public class Box<T> { private T content = new T(); // 错误: 不能实例化类型参数 }

如果需要创建类型参数的实例，可以通过传递 Class<T> 参数来实现：

public class Box<T> { private T content; public Box(Class<T> clazz) throws Exception { this.content = clazz.getDeclaredConstructor().newInstance(); } } 6. 总结

泛型是 Java 中一项强大的特性，它允许我们编写更加通用和类型安全的代码。通过自定义泛型类，我们可以创建适用于多种数据类型的类，从而提高代码的复用性和可维护性。尽管泛型在使用上有一些限制，但它在集合框架、自定义数据结构和泛型方法等场景中有着广泛的应用。