当前位置：首页 > news >正文

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

news 来源：原创 2025/5/10 13:00:38

泛型（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();
    }
}