什么时候使用泛型方法，什么时候使用通配符？

Question

我正在阅读来自OracleDocGenericMethod 的泛型方法。当它说何时使用通配符以及何时使用泛型方法时，我对比较感到非常困惑。 引用自文档。

interface Collection<E> {
    public boolean containsAll(Collection<?> c);
    public boolean addAll(Collection<? extends E> c);
}

我们可以在这里使用泛型方法：

interface Collection<E> {
    public <T> boolean containsAll(Collection<T> c);
    public <T extends E> boolean addAll(Collection<T> c);
    // Hey, type variables can have bounds too!
}

[…] 这告诉我们类型参数被用于多态性； 它的唯一作用是允许各种实际参数类型 在不同的调用站点使用。如果是这种情况，应该 使用通配符。通配符旨在支持灵活的子类型化， 这就是我们在这里想要表达的。

我们不认为像(Collection<? extends E> c); 这样的通配符也支持某种 多态性？那为什么泛型方法的使用在这方面被认为不好呢？

它指出，继续前进，

泛型方法允许使用类型参数来表达 方法的一个或多个参数类型之间的依赖关系 和/或其返回类型。如果没有这样的依赖，一个泛型 方法不应该使用。

这是什么意思？

他们已经给出了例子

class Collections {
    public static <T> void copy(List<T> dest, List<? extends T> src) {
    ...
}

[…]

我们可以用另一种方式为这个方法写签名， 完全不使用通配符：

class Collections {
    public static <T, S extends T> void copy(List<T> dest, List<S> src) {
    ...
}

该文件不鼓励使用第二个声明并提倡使用第一个语法？第一次和第二次声明有什么区别？两者似乎都在做同样的事情？

谁能照亮这个区域。

Answer 1

?表示未知

一般规则适用： 您可以从中读取，但不能写入

给定简单的 pojo 汽车

class Car {
    void display(){

    }
}

这将编译

private static <T extends Car> void addExtractedAgain1(List<T> cars) {
    T t = cars.get(1);
    t.display();
    cars.add(t);
}

这个方法不会编译

private static void addExtractedAgain2(List<? extends Car> cars) {
    Car car = cars.get(1);
    car.display();
    cars.add(car); // will not compile
}

另一个例子

List<?> hi = Arrays.asList("Hi", new Exception(), 0);

hi.forEach(o -> {
   o.toString() // it's ok to call Object methods and methods that don't need the contained type
});

hi.add(...) // nothing can be add here won't compile, we need to tell compiler what the data type is but we do not know

Answer 2

主要 -> 通配符在非泛型方法的参数/参数级别强制泛型。 笔记。默认情况下也可以在 genericMethod 中执行，但这里不是 ?我们可以使用 T 本身。

包泛型；

public class DemoWildCard {


    public static void main(String[] args) {
        DemoWildCard obj = new DemoWildCard();

        obj.display(new Person<Integer>());
        obj.display(new Person<String>());

    }

    void display(Person<?> person) {
        //allows person of Integer,String or anything
        //This cannnot be done if we use T, because in that case we have to make this method itself generic
        System.out.println(person);
    }

}

class Person<T>{

}

SO 通配符有类似这样的特定用例。

Answer 3

据我了解，只有一个用例是严格需要通配符（即可以表达一些使用显式类型参数无法表达的东西）。这是您需要指定下限的时候。

除此之外，通配符还可以编写更简洁的代码，如您提到的文档中的以下语句所述：

泛型方法允许使用类型参数来表达 方法的一个或多个参数类型之间的依赖关系 和/或其返回类型。如果没有这样的依赖，一个泛型 方法不应该使用。

[...]

使用通配符比显式声明更清晰、更简洁 类型参数，因此应尽可能首选。

[...]

通配符还有一个优点是可以在外面使用 方法签名，如字段、局部变量和数组的类型。

Answer 4

这里没有列出的另一个区别。

static <T> void fromArrayToCollection(T[] a, Collection<T> c) {
    for (T o : a) {
        c.add(o); // correct
    }
}

但是下面会导致编译时出错。

static <T> void fromArrayToCollection(T[] a, Collection<?> c) {
    for (T o : a) {
        c.add(o); // compile time error
    }
}

Answer 5

在您的第一个问题中：这意味着如果参数类型和方法的返回类型之间存在关系，则使用泛型。

例如：

public <T> T giveMeMaximum(Collection<T> items);
public <T> Collection<T> applyFilter(Collection<T> items);

在这里，您正在按照特定标准提取一些 T。如果 T 是 Long 你的方法将返回 Long 和 Collection<Long>;实际的返回类型取决于参数类型，因此建议使用泛型类型。

如果不是这种情况，您可以使用通配符类型：

public int count(Collection<?> items);
public boolean containsDuplicate(Collection<?> items);

在这两个示例中，无论集合中项目的类型如何，返回类型都是int 和boolean。

在你的例子中：

interface Collection<E> {
    public boolean containsAll(Collection<?> c);
    public boolean addAll(Collection<? extends E> c);
}

这两个函数将返回一个布尔值，无论集合中项目的类型是什么。在第二种情况下，它仅限于 E 的子类的实例。

第二个问题：

class Collections {
    public static <T> void copy(List<T> dest, List<? extends T> src) {
    ...
}

第一个代码允许您将异构List<? extends T> src 作为参数传递。这个列表可以包含多个不同类的元素，只要它们都扩展了基类 T。

如果你有：

interface Fruit{}

和

class Apple implements Fruit{}
class Pear implements Fruit{}
class Tomato implements Fruit{}

你可以的

List<? extends Fruit> basket = new ArrayList<? extends Fruit>();
basket.add(new Apple());
basket.add(new Pear());
basket.add(new Tomato());
List<Fruit> fridge = new ArrayList<Fruit>(); 

Collections.copy(fridge, basket);// works 

另一方面

class Collections {
    public static <T, S extends T> void copy(List<T> dest, List<S> src) {
    ...
}

将List<S> src 约束为一个特定的类 S，它是 T 的子类。列表只能包含一个类（在此实例中为 S）的元素，而不能包含其他类的元素，即使它们也实现了 T。您将无法使用我之前的示例，但您可以这样做：

List<Apple> basket = new ArrayList<Apple>();
basket.add(new Apple());
basket.add(new Apple());
basket.add(new Apple());
List<Fruit> fridge = new ArrayList<Fruit>();

Collections.copy(fridge, basket); /* works since the basket is defined as a List of apples and not a list of some fruits. */

Answer 6

考虑以下詹姆斯·高斯林 (James Gosling) 第 4 版的 Java 编程示例，我们要在其中合并 2 个 SinglyLinkQueue：

public static <T1, T2 extends T1> void merge(SinglyLinkQueue<T1> d, SinglyLinkQueue<T2> s){
    // merge s element into d
}

public static <T> void merge(SinglyLinkQueue<T> d, SinglyLinkQueue<? extends T> s){
        // merge s element into d
}

上述两种方法具有相同的功能。那么哪个更可取？答案是第2个。用作者自己的话来说：

“一般规则是尽可能使用通配符，因为使用通配符的代码 通常比具有多个类型参数的代码更具可读性。在决定是否需要类型时 变量，问问自己该类型变量是否用于关联两个或多个参数，或者关联一个参数 类型与返回类型。如果答案是否定的，那么通配符就足够了。”

注意：书中只给出了第二种方法，类型参数名称是 S 而不是 'T'。第一种方法书中没有。

Answer 7

在某些地方，通配符和类型参数做同样的事情。但也有一些地方，你必须使用类型参数。

1. 如果你想对不同类型的方法参数强制执行某种关系，你不能用通配符来做到这一点，你必须使用类型参数。

以您的方法为例，假设您要确保传递给copy() 方法的src 和dest 列表应该是相同的参数化类型，您可以像这样使用类型参数：

public static <T extends Number> void copy(List<T> dest, List<T> src)

在这里，您可以确保dest 和src 具有相同的List 参数化类型。因此，将元素从src 复制到dest 是安全的。

但是，如果你继续改变使用通配符的方法：

public static void copy(List<? extends Number> dest, List<? extends Number> src)

它不会按预期工作。在第二种情况下，您可以将List<Integer> 和List<Float> 传递为dest 和src。因此，将元素从 src 移动到 dest 将不再是类型安全的。 如果你不需要这种关系，那么你完全可以不使用类型参数。

使用通配符和类型参数之间的其他一些区别是：

• 如果您只有一个参数化类型参数，则可以使用通配符，尽管类型参数也可以。
• 类型参数支持多个边界，通配符不支持。

• 通配符同时支持上限和下限，类型参数只支持上限。因此，如果您想定义一个采用 List 类型为 Integer 或其超类的方法，您可以这样做：

  public void print(List<? super Integer> list)  // OK
  

  但你不能使用类型参数：

   public <T super Integer> void print(List<T> list)  // Won't compile
  

---

参考资料：

• Angelika Langer's Java Generics FAQs

Answer 8

我会尝试一一回答你的问题。

我们不认为像(Collection<? extends E> c); 这样的通配符也是 支持某种多态性？

没有。原因是有界通配符没有定义参数类型。这是一个未知数。它“知道”的只是“遏制”是E 类型（无论定义什么）。因此，它无法验证和证明提供的值是否与有界类型匹配。

因此，在通配符上使用多态行为是不明智的。

该文件不鼓励第二次声明并提倡使用 第一种语法？第一和第二有什么区别 宣言？两者似乎都在做同样的事情？

在这种情况下，第一个选项更好，因为T 始终是有界的，并且source 肯定会有（未知的）值是T 的子类。

因此，假设您要复制所有数字列表，第一个选项将是

Collections.copy(List<Number> dest, List<? extends Number> src);

src 基本上可以接受List<Double>、List<Float> 等，因为dest 中的参数化类型有一个上限。

第二个选项将强制您为要复制的每种类型绑定S，就像这样

//For double 
Collections.copy(List<Number> dest, List<Double> src); //Double extends Number.

//For int
Collections.copy(List<Number> dest, List<Integer> src); //Integer extends Number.

由于S 是需要绑定的参数化类型。

我希望这会有所帮助。

Answer 9

通配符方法也是通用的——你可以用一些类型来调用它。

<T> 语法定义了一个类型变量名。如果一个类型变量有任何用途（例如，在方法实现中或作为其他类型的约束），那么命名它是有意义的，否则你可以使用?，作为匿名变量。所以，看起来只是一个捷径。

此外，在声明字段时，? 语法是不可避免的：

class NumberContainer
{
 Set<? extends Number> numbers;
}