何时使用通用方法，何时使用通配符？

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）这样的通配符吗

它说，继续前进，

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

这是什么意思？

他们提出了一个例子

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

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

例如：

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

在这里，您将根据特定标准提取一些T。如果T是Long你的方法将返回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) {
    ...
}

第一个代码允许您传递异类列表

如果你有：

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<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 2

考虑下面的示例，从下面的詹姆斯·高斯林第四版的java编程中我们想合并2个SunLyLink队列：

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
}

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

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

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

Answer 3

在某些地方，通配符和类型参数可以做同样的事情。但也有一些地方需要使用类型参数。

1. 如果要在不同类型的方法参数上强制执行某种关系，则不能使用通配符，必须使用类型参数

以您的方法为例，假设您希望确保传递给Copp（）方法的src和的列表应该具有相同的参数化类型，您可以使用如下类型参数来实现：

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

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

>

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

但不能使用类型参数：

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

参考资料：

• Angelika Langer的Java通用常见问题解答