java - JLS 与类型转换相关

Question

我尝试从根本上理解 Java 中的类型转换，但无法理解 JLS 的某些部分。
特别是这个(将类类型 S 转换为类或接口(interface)类型 T 的含义):

Furthermore, if there exists a supertype X of T, and a supertype Y of S, such that both X and Y are provably distinct parameterized types (§4.5), and that the erasures of X and Y are the same, a compile-time error occurs.

以及这个(将接口(interface)类型 S 转换为最终类类型 T 的含义):

Otherwise, S is either a parameterized type that is an invocation of some generic type declaration G, or a raw type corresponding to a generic type declaration G. Then there must exist a supertype X of T, such that X is an invocation of G, or a compile-time error occurs. Furthermore, if S and X are provably distinct parameterized types then a compile-time error occurs.

也许有人可以举一些简短的例子来澄清这些摘录？

附注经过@ErickGHagstrom 的一些考虑和指导后，我想我可以对这两个棘手的 JLS 摘录进行澄清。

摘录 1。

JLS 说:

Two parameterized types are provably distinct if either of the following is true:

• They are parameterizations of distinct generic type declarations.

• Any of their type arguments are provably distinct.

和:

Two type arguments are provably distinct if one of the following is true:

• Neither argument is a type variable or wildcard, and the two arguments are not the same type.

• One type argument is a type variable or wildcard, with an upper bound (from capture conversion (§5.1.10), if necessary) of S; and the other type argument T is not a type variable or wildcard; and neither |S| <: |T| nor |T| <: |S| (§4.8, §4.10).

• Each type argument is a type variable or wildcard, with upper bounds (from capture conversion, if necessary) of S and T; and neither |S| <: |T| nor |T| <: |S|.

因此List<Integer>和List<Number>被证明是不同的，但是 List<? extends Integer>和List<? extends Number>不是(所有列出的类型都有相同的删除)。

关键点是，具有相同删除的两个可证明不同的参数化类型之间的子类型关系无论如何都是不可能的。

具有相同删除的两个可证明不同的参数化类型的子类型之间的子类型关系也是不可能的。如果S <: List<Integer>和T <: List<Number>然后铸件(T)S和(S)T即使在理论上，这两者也是不可能的。所以编译器会提示。

摘录 2。

这是我想出的示例(编译和运行没有错误):

    static final class T extends ArrayList<Number>{
    }

    static T t;

    static List<?> l1 = new T();
    static List<? extends Number> l2 = new T();
    static List<String> l3;

    public static void main(String[] args) {
        t = (T)l1;
        t = (T)l2;
//        t = (T)l3; //error
    }

您可以看到List<?>和List<? extends Number>可以转换到最终T而T不(也不能)实现这些接口(interface)中的任何一个。

T <: List<Number> 。 List<Number>是调用List<E>喜欢 List<?>和List<? extends Number> 。 List<Number>和List<?>和List<? extends Number>无法证明是不同的(见上文)。

如果我们想转换参数化接口(interface)类型的东西 S到 final类类型 T这个T 不需要显式或隐式地实现S 。但这T 必须实现另一个与 S 有子类型关系的参数化接口(interface)类型。关键在于，参数化类型之间的子类型关系不仅可以通过扩展或实现来定义，还可以通过类型参数包含来定义。

Answer 1

第一种情况:

ArrayList<String>与 ArrayList<Integer>具有相同的删除，ArrayList ，但可证明是不同的，因为没有 String可以转换为 Integer没有 Integer可以转换为 String .

第二种情况:

令G为List<T> S 为 List<String> 。假设我有一个类MyFinalArrayList像这样:

public final class MyFinalIntArrayList extends ArrayList<Integer> {
    ...
}

还有一个类似的

public final class MyFinalStrArrayList extends ArrayList<String> {
    ...
}

我可以将第一个转换到 List<Integer第二个是 List<String ，但反之则不然。