为什么不能传递 <?> 或 <?将 T> 泛型类实例扩展为期望 <?超级T>？

Question

PECS 原则是关于您在函数中选择哪种类型的参数，具体取决于您将如何使用该参数。 我的问题是，一旦您选择使用super（因为您的函数可能是消费者），您就不能将某些泛型类实例传递给该函数。

让我们考虑以下程序：

public class Main{
    public static void main(String[] args){
        List<?> unbound = new ArrayList<Long>();
        List<? extends Long> extendsBound = new ArrayList<Long>();
        List<? super Long> superBound = new ArrayList<Long>();

        takeExtend(unbound);
        takeExtend(extendsBound);
        takeExtend(superBound);

        takeSuper(unbound);
        takeSuper(extendsBound);
        takeSuper(superBound);
    }

    static <T> void takeExtend(List<? extends T> l){}
    static <T> void takeSuper(List<? super T> l){}
}

编译器给出以下错误：

error: method takeSuper in class Main cannot be applied to given
types;
        takeSuper(unbound);
        ^   required: List<? super T>   found: List<CAP#1>   reason: cannot infer type-variable(s) T
    (argument mismatch; List<CAP#1> cannot be converted to List<? super T>)   where T is a type-variable:
    T extends Object declared in method <T>takeSuper(List<? super T>)   where CAP#1 is a fresh type-variable:
    CAP#1 extends Object from capture of ?

我试图找到一种对称性，例如我们为 PECS 规则提供的对称性，但我没有找到。 所以：

• 为什么不能将<?> 或<? extends T> 传递给期望<? super T> 的函数？
• 为什么可以将<?> 传递给需要<? extends T> 的函数？
• 为什么可以将 <? super T> 传递给需要 <? extends T> 的函数？

Answer 1

您可以将泛型方法（即具有自己的类型参数的方法）视为对其类型参数进行一组声明。

例如，方法 <T> someMethod(List<T>) 表示：

存在一些类型T，该列表的类型参数等于T。

简单。所有列表都符合此标准，因此任何列表都是该方法的有效输入。

方法中的所有内容现在都可以利用该陈述为真的知识。这些知识有什么用？好吧，如果我们从列表中获取一个项目，我们就知道它与列表的类型参数匹配。因为我们将类型捕获为T，所以我们可以持有对该对象的引用并稍后将其放回列表中，但仍然不知道它到底是什么类型。

方法声明 <T> someMethod(List<? extends T>) 做了一个稍微不同的声明：

存在一些类型T，该列表的类型参数是T的子类型。

这对于所有列表也是如此。但是，您可能会注意到它使<T> someMethod(List<? extends T>) 有点无用。您告诉编译器捕获列表中的项目与列表中的其他项目共享一些公共超类型的事实。除非您在方法中拥有其他已知接受<? super T> 的消费者，否则您无法处理该信息。它远不如知道来自列表的所有项目都属于同一类型。

---

那么，为什么<T> takeSuper(List<? super T>) 的工作方式不同？

方法声明<T> takeSuper(List<? super T>)可以解释为声称：

存在一些类型T，该列表的类型参数是T的超类型。

如果我们有一个List<? super Long> 并将它传递给一个捕获<T> takeSuper(List<? super T>) 的方法，那么很容易看出Long 类型的引用将满足T。我们可以将Long 作为T 类型的参数传递给方法，然后从方法内部将其添加到列表中。

但是如果我们有一个List<?> 并且我们使用<T> takeSuper(List<? super T>) 方法捕获它的类型呢？通过将列表声明为List<?>，我们说我们目前不知道它的类型参数是什么。在这样做时，我们告诉编译器我们绝对无法获得与列表的类型参数匹配的类型的引用。换句话说，编译器确定没有对象可以满足类型参数T。请记住，对于此方法，如果 已知 对象的类型是列表的类型参数的子类型，则该对象的类型为 T。如果我们对列表的类型参数一无所知，那是不可能的。

List<? extends Long> 也是如此。我们知道我们从列表中获取的项目将是Long 的子类型，但我们没有为它们的类型设置下限。我们永远无法证明任何类型都是列表类型参数的子类型。因此，对于<T> takeSuper(List<? super T>) 方法，再次证明无法获得T 类型的引用。

有趣的是，我的编译器 (Java 8) 并没有抱怨使用 List<?> 作为输入来调用方法 <T> takeSuper(List<? super T>)。我想它认识到，由于无法获得T 类型的引用，因此忽略无用的类型参数并没有什么坏处。

Answer 2

为什么不能将<?> 或<? extends T> 传递给期望<? super T> 的函数？

考虑这种方法：

static <T> void sillyAdd(List<? super T> l, T t){
  l.add(t);
}

现在看看如果可能的话我们可以如何使用它：

List<Integer> onlyIntegers = new ArrayList<>();
List<? extends Number> anyNumber = onlyIntegers;
sillyAdd(anyNumber, Float.valueOf(0)); /* Not allowed... */
Integer i = onlyIntegers.get(0);

最后一行会抛出一个ClassCastException，因为我们可以将Float 放入List<Integer>。

为什么可以将<?> 传递给期望<? extends T> 的函数？

takeExtend(unbound);

T 没有界限；它可以是任何类型。虽然unbound 的类型参数是unknown，但它确实有some 类型，并且由于T 可以是任何类型，所以它是匹配的。

像这样的方法有时会在泛型的某些奇怪角落用作帮助器。逻辑上，我们知道以下应该没问题：

public static void rotate(List<?> l) {
  l.add(l.remove(0));
}

但是泛型的规则在这里并不意味着类型安全。相反，我们可以使用这样的帮助器：

public static void rotate(List<?> l) {
  helper(l);
}

private static <T> void helper(List<T> l) {
  l.add(l.remove(0));
}

为什么可以将<? super T> 传递给期望<? extends T> 的函数？

在某种程度上，它不是。给定这个例子：

static <T> void takeExtend(List<? extends T> l)

List<? super Long> superBound = new ArrayList<Long>();
takeExtend(superBound);

您可能认为T 被推断为Long。这意味着您将List<? super Long> 传递给声明为void takeExtend(List<? extends Long> l) 的方法，这似乎是错误的。

但T 不会被推断为Long。如果你明确指定 Long 作为类型参数，你会发现它不起作用：

Main.<Long>takeExtend(superBound);

实际发生的情况是T 被推断为? super Long，因此该方法的泛型类型类似于void takeExtend(List<? extends ? super Long>)。这意味着列表中的所有内容都扩展了未知的超类Long。

Answer 3

• 为什么不能将<?> 或<? extends S> 传递给期望<? super T> 的函数？ （为清楚起见更正了问题：? 扩展 S）。

编译器想要推断出 T，它是下限，但它不能。每个类都扩展了 Object，但没有通用的继承树底层类，编译器可以默认使用它。

• 为什么可以将<?> 传递给需要<? extends T> 的函数？

这是关于推理的。您可以传递<?>，因为编译器可以从中做出一些事情。也就是说，它可以将Object从T中取出来。下面的情况也是如此：

List<?> unbound = new ArrayList<>();

• 为什么可以将 <? super T> 传递给需要 <? extends T> 的函数？

再次，现在是关于推断上限，因此编译器可以默认为 Object。它对什么不感兴趣？对任何东西都超级，也不是对任何东西都超级。

Answer 4

在你们 cmets 的惊人帮助下，我整晚都在想这些东西，试图找到一个容易记住的解决方案。

这就是我得到的。 接受<? extends T> 的方法要获得T，必须推断出该层次结构的上限。由于在 Java 中每个类都在扩展 Object，因此编译器可以依赖于这样一个事实，即至少上限是 Object。所以：

• 如果我们传递一个<? extends T>，则上限已经定义并且它 将使用那个
• 如果我们通过<?>，我们什么都不知道，但我们知道 每个类都扩展了 Object，所以编译器会推断出Object
• 如果我们通过<? super T>，我们知道下限，但是由于每个类 extends Object，编译器推断Object。

接受<? super T> 的方法要获得T，必须推断出该层次结构的下限。默认情况下，在 Java 中，我们可以依靠上限，但不能依靠下限。因此，在前一个案例中所做的考虑不再有效。所以：

• 如果我们通过<? extends T>，则没有下限，因为 层次结构可以随心所欲地扩展
• 如果我们通过<?>， 没有下界，因为层次结构可以扩展为 随心所欲
• 如果我们通过<? super T>，下限已经是 定义，所以我们可以使用那个。

重述：

• 接受<? extends T> 的方法始终可以依赖于以下事实： 存在一个上限，即 Object -> 我们可以将每个边界传递给它
• 接受<? super T> 的方法只有在参数中明确定义时才能推断出下限 -> 我们只能传递<? super T>