Java泛型中占位符T和?有哪些区别

在Java泛型编程中，T和?是两个常见的占位符，它们用于表示类型参数。尽管它们都用于泛型中，但它们的用途和行为有很大的不同。本文将详细探讨T和?的区别，帮助开发者更好地理解和使用它们。

1. T 和 ? 的基本概念

1.1 T 的基本概念

T 是一个类型参数（Type Parameter），通常用于定义泛型类、泛型接口或泛型方法。T 代表一个具体的类型，可以在定义时指定，也可以在使用时通过类型推断来确定。

public class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

在上面的例子中，T 是一个类型参数，表示 Box 类可以存储任意类型的对象。在使用时，可以指定 T 的具体类型，例如 Box<String> 或 Box<Integer>。

1.2 ? 的基本概念

? 是一个通配符（Wildcard），用于表示未知类型。它通常用于泛型方法的参数类型或泛型类的字段类型，表示可以接受任何类型的参数。

public void printList(List<?> list) {
    for (Object item : list) {
        System.out.println(item);
    }
}

在上面的例子中，List<?> 表示可以接受任何类型的 List，例如 List<String>、List<Integer> 等。

2. T 和 ? 的主要区别

2.1 使用场景

• T：T 通常用于定义泛型类、泛型接口或泛型方法时，表示一个具体的类型参数。它可以在类或方法的定义中使用，并且可以在使用时指定具体的类型。

• ?：? 通常用于泛型方法的参数类型或泛型类的字段类型，表示可以接受任何类型的参数。它不能用于定义泛型类或泛型方法。

2.2 类型安全

• T：由于 T 是一个具体的类型参数，编译器可以在编译时进行类型检查，确保类型安全。例如，Box<String> 只能存储 String 类型的对象。

• ?：? 表示未知类型，编译器无法进行具体的类型检查。因此，使用 ? 时，类型安全性较低。例如，List<?> 可以存储任何类型的对象，但在使用时需要进行类型转换。

2.3 类型操作

• T：T 可以在泛型类或泛型方法中进行类型操作，例如创建对象、调用方法等。例如，T 可以用于创建数组或调用 T 类型的方法。

public <T> T createInstance(Class<T> clazz) throws Exception {
    return clazz.newInstance();
}

• ?：? 不能用于类型操作，因为它表示未知类型。例如，不能使用 ? 创建对象或调用方法。

public void processList(List<?> list) {
    // 不能使用 list.add(new Object())，因为 ? 表示未知类型
}

2.4 上下界

• T：T 可以使用上下界来限制类型的范围。例如，T extends Number 表示 T 必须是 Number 或其子类。

public class Box<T extends Number> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

• ?：? 也可以使用上下界来限制类型的范围。例如，List<? extends Number> 表示 List 中的元素必须是 Number 或其子类。

public void printNumbers(List<? extends Number> list) {
    for (Number number : list) {
        System.out.println(number);
    }
}

3. 总结

• T 是一个具体的类型参数，用于定义泛型类、泛型接口或泛型方法，可以在使用时指定具体的类型。
• ? 是一个通配符，用于表示未知类型，通常用于泛型方法的参数类型或泛型类的字段类型。
• T 提供了更高的类型安全性，而 ? 提供了更大的灵活性。
• T 可以用于类型操作，而 ? 不能用于类型操作。
• T 和 ? 都可以使用上下界来限制类型的范围。

通过理解 T 和 ? 的区别，开发者可以更好地利用Java泛型来编写类型安全且灵活的代码。