为什么谓词<？ super SomeClass> 不适用于对象？

Question

假设我们有一个声明为Predicate<? super SomeClass> 的谓词。我天真地期望它适用于层次结构上的任何SomeClass 超类，包括Object。

但是这个谓词不适用于Object。我收到以下错误：

Predicate 类型中的方法 test(capture#3-of ? super SomeClass) 不适用于参数（Object）

Demo.

为什么Predicate<? super SomeClass> 不适用于Object 的实例？

代码：

import java.util.*;
import java.lang.*;
import java.io.*;
import java.net.URL;
import java.util.function.Predicate;


/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
    public static void main (String[] args) throws java.lang.Exception
    {
        Predicate<? super URL> p = u -> u.getFile().isEmpty();
        p.test(new Object());
    }
}

Answer 1

对于Predicate<? super SomeClass> 变量，您可以分配Predicate<SomeClass> 实例或Predicate<Object> 实例。

但是，您不能将Object 传递给Predicate<SomeClass> 的test() 方法。你只能传递一个SomeClass 实例。

因此，您不能将Object 传递给Predicate<? super SomeClass> 的test() 方法

考虑以下几点：

Predicate<URL> p1 = u -> u.getFile().isEmpty();
Predicate<? super URL> p2 = p1;

p2 指的是Predicate<URL>，因此您不能将new Object() 传递给它的test() 方法。

换句话说，为了让编译器接受p.test(new Object())，它必须对可以分配给Predicate<? super URL> p 变量的任何 Predicate 有效。由于Predicate<URL> Predicate 可以分配给该变量，并且其test() 方法不能接受Object，因此编译器无法接受p.test(new Object())。

顺便说一句，在您的具体示例中，您正在创建一个Predicate<URL>，而URL 是一个最终类。因此，您应该简单地将其声明为：

Predicate<URL> p = u -> u.getFile().isEmpty();

? super 或 ? extends 没有任何理由。

Answer 2

谓词已经有一个类型。谓词接受的类型在您尝试调用它时无法确定。它有一个类型，那个类型是 X 的某个超类；只是未知。

如果我有一个Predicate<Collection>，则可以将其引用为Predicate<? super List>。但这并不意味着它会接受任何Object。 ? extends X 泛型类型并不意味着它会接受与给定约束匹配的任何东西。这意味着它是某种与给定约束匹配的未知类型的谓词。

Predicate<? super List> predicate = Collection::isEmpty;
predicate.test(new Object()); // Should this be valid? Clearly not

Answer 3

Java 教程页面提供了一些关于使用泛型时upper / lower 有界通配符的有用信息。

它还提供了一些guidelines 用于使用通配符，这可以帮助您决定应该使用哪个通配符：

一个“入”变量 “in”变量为代码提供数据。想象一个带有两个参数的复制方法：copy(src, dest)。 src 参数提供 要复制的数据，所以它是“in”参数。 “出”变量 “out”变量保存在其他地方使用的数据。在复制示例 copy(src, dest) 中，dest 参数接受数据，因此它是 "out" 参数。

当然，有些变量同时用于“输入”和“输出”目的—— 指南中也提到了这种情况。

在决定是否使用时，可以使用“in”和“out”原则 通配符以及合适的通配符类型。下列 列表提供了要遵循的准则： 通配符准则：

An "in" variable is defined with an upper bounded wildcard, using the extends keyword.
An "out" variable is defined with a lower bounded wildcard, using the super keyword.
In the case where the "in" variable can be accessed using methods defined in the Object class, use an unbounded wildcard.
In the case where the code needs to access the variable as both an "in" and an "out" variable, do not use a wildcard.

这些准则不适用于方法的返回类型。用一个 应避免使用通配符作为返回类型，因为它强制 程序员使用代码来处理通配符。

Answer 4

考虑更广泛的例子：

Predicate<? super Integer> p;

在这种情况下，以下任何赋值都是有效的，对吧？

p = (Predicate<Integer>) i -> true; // but, only Integer can be applied
p = (Predicate<Number>)  n -> true; // Number and its sub-classes (Integer, Double...)
p = (Predicate<Object>)  o -> true; // any type

所以，如果最后是：

Predicate<? super Integer> p  = (Predicate<Integer>) i -> true;

那么，当然，Number 和 Object 都不能应用于谓词。

为了保证类型安全，编译器只允许那些对Predicate<? super Integer> 的任何可能赋值有效的类型 - 因此，在这个特定示例中，只允许Integer。

将下界从Integer 更改为Number 分别扩展边界：

Predicate<? super Number> p  = (Predicate<Number>) n -> true;

现在，谓词可以应用于Number 及其任何子类：Integer、Double 等。

总结

唯一可以应用于Predicate<? super SomeClass>而不破坏类型安全保证的类型：下限本身及其子类。

Answer 5

这是一个相当复杂的主题。这些? extends T 和? super T 声明应该在类之间创建“匹配”。

如果一个类定义了一个接受Consumer的方法，比如Iterable<T>.foreach()，它定义这个消费者接受所有可以接受T的东西。因此，它defines it as forEach(Consumer<? super T> action)。为什么？因为Iterator<Integer> 的foreach() 可以用Consumer<Number> 甚至Consumer<Object> 调用。如果没有? super T，这是不可能实现的。

OTOH，如果一个类定义了一个采用Supplier 的方法，比如addFrom，它定义了这个供应商来提供所有T。因此，它将其定义为addFrom(Supplier<? extends T> supplier)。为什么？因为ThisClass<Number> 的addFrom() 可以用Supplier<Integer> 或Supplier<Double> 调用。如果没有? extends T，这是不可能的。

对于后者来说可能是一个更好的例子：List<E>.addAll() 接受 Collection<? extends E>。这使得将List<Integer> 的元素添加到List<Number> 成为可能，但反之则不行。