何时使用通用方法以及何时使用通配符？

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

某些地方,通配符和类型参数执行相同的操作.但也有一些地方,你必须使用类型参数.

1. 如果要对不同类型的方法参数强制实施某些关系,则不能使用通配符,必须使用类型参数.

以您的方法为例,假设您要确保传递给方法的src和dest列表copy()应该具有相同的参数化类型,您可以使用类型参数来执行此操作:

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的Java Generics常见问题解答

Answer 2

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

例如:

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 3

请考虑下面的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
}

上述两种方法都具有相同的功能.那么哪个更好？答案是第二个.用作者自己的话说:

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

注意:在书中只给出了第二种方法,类型参数名称是S而不是'T'.第一种方法不在书中.