JAVA——泛型-EW帮帮网

泛型（Generics）是Java语言在JDK 5.0版本中引入的一种强大特性，用于在编译时提供更强的类型检查和类型安全。它允许程序员在定义类、接口和方法时使用类型参数（Type Parameters），从而实现类型参数化。通过泛型，可以编写出更加通用、灵活且类型安全的代码。

一、泛型的核心概念

1. 类型参数化

泛型的核心思想是通过类型参数化，使类、接口和方法能够处理多种数据类型，而不是单一的类型。这样可以提高代码的复用性和灵活性。

例如，没有泛型时，集合只能存储Object类型的数据：

List list = new ArrayList();
list.add("Hello");
list.add(123);

这种方式存在类型不安全的问题，因为集合中可以存储任意类型的对象，访问时需要进行类型转换。

使用泛型后，可以指定集合中存储的类型：

List<String> list = new ArrayList<>();
list.add("Hello");
// list.add(123); // 编译错误，类型不匹配

这种方式在编译时就能保证类型安全，避免了运行时的ClassCastException。

2. 类型参数

类型参数是泛型的核心组成部分。它们是类、接口或方法中定义的占位符，用于表示具体的类型。常见的类型参数包括：

T（Type）

E（Element）

K（Key）

V（Value）

N（Number）

例如：

public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

在这个例子中，T是一个类型参数，表示Box类可以处理任意类型的对象。

3. 类型擦除

Java的泛型是通过类型擦除实现的。在编译时，泛型信息会被擦除，所有泛型类型参数都会被替换为Object。这意味着运行时无法获取泛型的具体类型信息。

例如：

Box<String> box = new Box<>();
// 编译后，运行时的类型为 Box<Object>

类型擦除的目的是保持与Java 5.0之前的版本兼容，但这也带来了一些限制，比如不能创建泛型数组。

二、泛型的常见用法

1. 泛型类

泛型类是使用类型参数定义的类。通过泛型类，可以创建适用于多种数据类型的对象。

例如：

public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

使用泛型类：

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

Box<Integer> intBox = new Box<>();
intBox.setContent(123);
Integer content2 = intBox.getContent();

2. 泛型接口

泛型接口是使用类型参数定义的接口。通过泛型接口，可以创建适用于多种数据类型的实现类。

例如：

public interface List<T> {
    void add(T element);
    T get(int index);
}

实现泛型接口：

public class ArrayList<T> implements List<T> {
    private T[] elements;
    private int size;

    public ArrayList() {
        elements = (T[]) new Object[10];
    }

    @Override
    public void add(T element) {
        if (size == elements.length) {
            // 扩容逻辑
        }
        elements[size++] = element;
    }

    @Override
    public T get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        return elements[index];
    }
}

3. 泛型方法

泛型方法是使用类型参数定义的方法。通过泛型方法，可以在方法中处理多种数据类型。

例如：

public class Util {
    public static <T> void print(T element) {
        System.out.println(element);
    }
}

使用泛型方法：

Util.print("Hello");
Util.print(123);
Util.print(3.14);

三、泛型的高级特性

1. 通配符（Wildcards）

通配符?用于表示未知类型，可以用于更灵活的类型匹配。

例如：

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

这里的?表示list可以引用任何类型的List对象，但不能添加元素（除了null）。

2. 有界通配符（Bounded Wildcards）

有界通配符用于限制通配符的类型范围。有两种形式：

? extends T：表示类型参数是T的子类型。
? super T：表示类型参数是T的父类型。

例如：

List<? extends Number> list = new ArrayList<Integer>();

这里的? extends Number表示list可以引用任何Number的子类型的List对象。

List<? super Integer> list = new ArrayList<Number>();

这里的? super Integer表示list可以引用任何Integer的父类型的List对象。

3. 泛型方法的类型推断

Java编译器可以自动推断泛型方法的类型参数，从而简化代码。

例如：

public static <T> void print(T element) {
    System.out.println(element);
}

调用时：

print("Hello"); // 编译器推断 T 为 String
print(123); // 编译器推断 T 为 int

四、泛型的限制

1. 不能使用基本数据类型

泛型类型参数必须是引用类型，不能是基本数据类型。如果需要使用基本数据类型，必须使用对应的包装类。

例如：

List<int> list = new ArrayList<>(); // 错误
List<Integer> list = new ArrayList<>(); // 正确

2. 类型擦除

泛型信息在运行时会被擦除，因此无法在运行时获取泛型的具体类型。

例如：

Box<String> box = new Box<>();
// 运行时无法知道 box 的具体类型是 String

3. 不能创建泛型数组

不能直接创建泛型数组，但可以创建泛型集合。

例如：

Box<String>[] boxes = new Box<String>[10]; // 错误
Box<String>[] boxes = new Box[10]; // 正确，但类型安全警告

总结

泛型是Java语言中一个非常强大的特性，通过类型参数化提供了更强的类型安全性和代码复用性。通过泛通用，可以编写出更加通用、灵活且类型安全的代码，同时减少运行时的类型转换错误。了解泛通用的基本规则和高级特性，可以帮助您更好地利用这一特性来编写高质量的Java代码。

JAVA——泛型