结合 <?扩展 ClassE> 和 <?超级B类>

Question

我怎么理解？延伸..和？ super .. 自己工作，哪些泛型类型是可能的，但我就是不明白这个层次结构如何实现以下内容：

-> 表示扩展

等级为 X（最低），A 到 E（最高）

接口是F

X -> A（实现 F）-> B -> C -> E（实现 F）

还有 D -> E

public class Node<T extends ClassE> {
    private T info;

    public T getInfo() {
        return info;
    }

    public void setInfo(T info) {
        this.info = info;
    }
}

public static void main (String [] args){

    Node<? super ClassB> n2 = new Node<ClassC>(); 
// this makes sense, since Node accepts below E and above B

    InterfaceF i2 = n2.getInfo();
// how? Not only outside of <? extends E> but also getting value even though 
// <? super B> is defined above, what's up with PECS?

    n2.setInfo(new ClassX());
// also.. how? I'm setting a class that's out of the allowed range + 
// seemingly violating the PECS for <? extends E>
}

正如您所看到的，在组合它们时我完全感到困惑，而且让这些声明毫无问题地通过编译器让我感到非常惊讶。 我在某处读到，在 Java 中不可能同时使用这两种界限，但那它是如何工作的呢？

Answer 1

第一行InterfaceF i2 = n2.getInfo(); 编译，因为下界通配符仍然保留类型变量本身的界限。由于类型变量有一个上限ClassE，getInfo() 仍然返回一个ClassE。由于ClassE 实现了InterfaceF，因此赋值编译。

换句话说，我们可以想象，当您执行Node<? super ClassB> 时，您实际上隐含地执行了类似（虚构语法）Node<? extends ClassE & super ClassB> 的操作。 Node 的类型参数既是ClassB 的超类型，又是ClassE 的子类型。

这类似于Node<?> 隐含地与Node<? extends ClassE> 相同。

实际指定的方式有点复杂，但它在capture conversion 中。捕获转换是编译器获取带有通配符的类型并将其视为没有通配符的类型的过程，目的是确定子类型。

让G 用n 类型参数A<sub>1</sub>,...,A<sub>n</sub> 和对应的边界U<sub>1</sub>,...,U<sub>n</sub> 命名一个泛型类型声明。

存在从参数化类型G&lt;T<sub>1</sub>,...,T<sub>n</sub>&gt; 到参数化类型G&lt;S<sub>1</sub>,...,S<sub>n</sub> 的捕获转换，其中，对于1 ≤ i ≤ n：

• [...]

• 如果T<sub>i</sub> 是? super B<sub>i</sub> 形式的通配符类型参数，则S<sub>i</sub> 是一个新类型变量，其上限为U<sub>i</sub>[A<sub>1</sub>:=S<sub>1</sub>,...,A<sub>n</sub>:=S<sub>n</sub>]，下限为B<sub>i</sub>。

换言之，S<sub>i</sub>（捕获转换后对应? super ClassB的类型参数）从通配符的边界获取其下限，从类型变量声明的边界获取其上限。

第二行n2.setInfo(new ClassX()); 可以编译，因为ClassX 是ClassB 的子类，所以它可以隐式转换为它。我们可以想象n2 是Node<ClassB>，这行编译的原因可能更明显：

Node<ClassB> n2 = ...;
n2.setInfo(new ClassX());

setInfo 接受ClassB 以及ClassB 的任何子类型。

另外，关于这个：

我在某处读到，Java 中不可能同时使用这两个边界，但那是如何工作的呢？

编译器中的类型系统做了很多我们自己无法明确做的事情。另一个很好的例子（虽然不相关）是匿名类的类型推断：

int num = Objects.requireNonNull(new Object() {int num = 42;}).num;
System.out.println(num); // 42

它编译是因为允许类型推断推断requireNonNull 的T 的类型参数是匿名对象类型，即使我们自己永远无法将该类型作为显式类型参数提供。

Answer 2

免责声明：我不知道具体的类型推断规则，但请解释为我的最佳理解。

关于InterfaceF i2 = n2.getInfo() - 因为Node<T extends E> 保证Node.getInfo() 返回一些extends E。根据您的描述E implements F。这样可以确保T extends E 也将implement F。因此Node.getInfo() = T extends E implements F。所以n2.getInfo() implements F 很好。

关于n2.setInfo(new ClassX()) - 我没有像上面那样正式的解释，但让我们试着考虑一下：基本上你Node<? super ClassB>告诉大家期待 最多 ClassB 是Node 内容的最低值。然而，由于ClassX 传递继承ClassB，它完全有效，因为它将满足? super ClassB 提出的所有接口保证。

希望这会有所帮助！

Answer 3

public class Test {
    public interface F {}
    public static class E implements F {}
    public static class D extends E {}
    public static class C extends E {}
    public static class B extends C {}
    public static class A extends B implements F {}
    public static class X extends A {}

    public static class Node<T extends E> {
        private T info;
        public T getInfo() {return info;}
        public void setInfo(T info) {this.info = info;}
    }

    public static void main(String[] args) {
        Node<? super B> n = new Node<C>(); // C is superclass of B = OK
        F i = n.getInfo(); // node type = B|C|E all these types implements F (since E implements F) = OK
        n.setInfo(new X()); // X has supertypes A,B,C,E = can be casted to B and so satisfy <? super B>
    }
}