7

所以我正在阅读泛型以重新熟悉这些概念，尤其是在涉及通配符的地方，因为我几乎从未使用过它们或遇到过它们。从我所做的阅读中，我无法理解他们为什么使用通配符。我经常遇到的一个例子如下。

void printCollection( Collection<?> c ) {
  for (Object o : c){
    System.out.println(o);
  }
}

你为什么不把它写成：

<T> void printCollection( Collection<T> c ) {
    for(T o : c) {
        System.out.println(o);
    }
}

oracle网站的另一个例子：

public static double sumOfList(List<? extends Number> list) {
    double s = 0.0;
    for (Number n : list)
        s += n.doubleValue();
    return s;
}

为什么这不写成

public static <T extends Number> double sumOfList(List<T> list) {
    double s = 0.0;
    for (Number n : list)
        s += n.doubleValue();
    return s;
}

我错过了什么吗？

4

3 回答 3

3

来自甲骨文：

出现的一个问题是：什么时候应该使用泛型方法，什么时候应该使用通配符类型？为了理解答案，让我们检查一下 Collection 库中的一些方法。

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!
 }

但是，在 containsAll 和 addAll 中，类型参数 T 只使用一次。返回类型不依赖于类型参数，也不依赖于方法的任何其他参数（在这种情况下，只有一个参数）。这告诉我们类型参数被用于多态性；它的唯一作用是允许在不同的调用站点使用各种实际的参数类型。如果是这种情况，应该使用通配符。通配符旨在支持灵活的子类型化，这就是我们在这里想要表达的。

因此，对于第一个示例，这是因为操作不依赖于类型。

第二，因为它只依赖于 Number 类。

于 2013-02-28T02:16:02.330 回答
3

为什么要让事情变得比他们需要的更复杂？这些示例演示了可能可行的最简单的事情——这些示例并不是试图说明通用方法。

你为什么不把它写成：

<T> void printCollection( Collection<T> c ) {
    for(T o : c) {
        System.out.println(o);
    }
}

因为System.out.println()可以接受对象，所以不需要更具体。

为什么这不写成

public static <T extends Number> double sumOfList(List<T> list) {
    double s = 0.0;
    for (Number n : list)
        s += n.doubleValue();
    return s;
}

同样，因为您不需要为每个不同的T extends Number. 接受 a 的非泛型方法List<? extends Number>就足够了。

于 2013-02-28T01:09:27.313 回答
3

确实，如果方法参数类型具有带上限的第一级通配符，则可以将其替换为类型参数。

反例（通配符不能被类型参数替换）

    List<?> foo()  // wildcard in return type  

    void foo(List<List<?>> arg)   // deeper level of wildcard

    void foo(List<? super Number> arg)   // wildcard with lower bound

现在对于可以通过通配符或类型参数解决的情况

        void foo1(List<?> arg)

    <T> void foo2(List<T> arg)

一般认为foo1() 比foo2(). 这可能有点主观。我个人认为foo1()签名更容易理解。并且foo1()在行业中被压倒性地采用，因此最好遵循惯例。

foo1()也处理arg得更抽象一点，因为你不能轻易地arg.add(something)在foo1(). 当然，这可以很容易地解决（即将 arg 传递给foo2()！）。公共方法看起来像一个常见的做法foo1()，它在内部转发给私有方法foo2()。

在某些情况下，通配符不起作用并且需要类型参数：

    <T> void foo(List<T> foo1, List<T> foo2);  // can't use 2 wildcards.

到目前为止，这个讨论是关于方法签名的。在其他地方，在无法引入类型参数的情况下，通配符可能是必不可少的。

于 2013-02-28T01:20:20.190 回答