Question

我有TypeToken类用来表示这样的通用类型：
TypeToken<List<String>> listOfStrings = new TypeToken<List<String>> {}
而且工作正常，TypeToken只是class TypeToken<T> {}，具有简单的获取该类型的方法。

现在，我想为List这样的常见类型创建简单的方法，以实现更动态的使用：
TypeToken<List<? extends Number>> numbers = list(extendsType(Number.class))
使用：

public static <T> TypeToken<? extends T> extendsType(Class<T> type) {return null;}
public static <T> TypeToken<List<T>> list(TypeToken<T> type) {return null;}

（返回空值，因为我只询问编译器而不是逻辑）

但是由于某些原因，这与我的预期不符：（因为我希望有效的代码无法编译，而我希望无效的代码却可以编译）

class TypeToken<X> {
    static <T> TypeToken<? extends T> extendsType(Class<T> type) {return null;}
    static <T> TypeToken<List<T>> list(TypeToken<T> type) {return null;}
    static void wat() {
        TypeToken<List<? extends Number>> a = new TypeToken<List<? extends Number>>() {}; // valid
        TypeToken<List<? extends Number>> b = list(extendsType(Number.class)); // invalid, why?
        TypeToken<? extends List<? extends Number>> c = list(extendsType(Number.class)); // valid, why?
    }
}

我在这里做错了什么？是什么导致泛型的行为如此？

我正在使用JDK 11，但我也在JDK 8上进行了测试

编译器错误：

error: incompatible types: no instance(s) of type variable(s) T#1,CAP#1,T#2 exist so that TypeToken<List<T#1>> conforms to TypeToken<List<? extends Number>>
            TypeToken<List<? extends Number>> b = list(extendsType(Number.class)); // invalid, why?
                                                      ^
  where T#1,T#2 are type-variables:
    T#1 extends Object declared in method <T#1>list(TypeToken<T#1>)
    T#2 extends Object declared in method <T#2>extendsType(Class<T#2>)
  where CAP#1 is a fresh type-variable:
    CAP#1 extends T#2 from capture of ? extends T#2

Answer 1

我认为这个问题已经以类似的形式被问过几次了。但是我不确定，因为这是一个很难在这个概念上扎头的星座。

也许人们可以这样想象：

此处的extendsType方法返回一个TypeToken<? extends Number>
在对list方法的调用中，?被捕获在类型参数T中。可以将捕获捕获（大致而言）想象为一个新的类型变量-类似于X extends Number，该方法返回一个TypeToken<List<X>>

根据常规约束，现在TypeToken<List<X>>无法分配给TypeToken<List<? extends Number>>。也许该表以<===表示可分配性，而<=/=表示不可分配性，将有帮助：

                    Number                     <===                Integer
TypeToken<          Number>                    <=/=      TypeToken<Integer>
TypeToken<? extends Number>                    <===      TypeToken<Integer>
                    List<? extends Number>     <===                List<X>
TypeToken<          List<? extends Number>>    <=/=      TypeToken<List<X>>
TypeToken<? extends List<? extends Number>>    <===      TypeToken<List<X>>

因此，最后，answer to the question which super-subtype relationships exist among instantiations of generic types in the famous Generics FAQ by Angelika Langer可能再次在这里最相关：

泛型类型的实例之间的超子类型关系由两个正交方面确定。

一方面，在父类型和子类型之间存在继承关系。

...

另一方面，存在基于类型参数的关系。前提条件是所涉及的类型参数中至少有一个是通配符。例如，Collection<? extends Number>是Collection<Long>的超类型，因为类型Long是通配符" ? extends Number "表示的类型族的成员。

^{我认为捕获是“新型X”的想法听起来很有说服力，尽管其中涉及一些手动操作：这在解析过程中“隐式”发生，并且不可见在代码中，但是当我写了一个library for types时出现了所有这些问题时，我发现它在一定程度上很有帮助...}

已更新，以进一步详细说明，请参见注释：

我提到类型“由于通常的约束”是不可分配的。现在，人们可以争论这些“约束”的来源。但是它们基本上总是有相同的原因：类型是不可分配的，因为 if 是可分配的，所以程序将不是类型安全的。（这意味着有可能以一种或另一种方式触发ClassCastException。）

说明此处丢失类型安全性的位置（以及可能导致ClassCastException的原因）涉及一些扭曲。我将根据注释中引用的示例尝试在此处显示它。向下滚动到 tl; dr ，以获取具有相同结构但更简单的示例。

评论中的示例是这样：

import java.util.*;
import java.io.*;

class Ideone
{
    public static class LinkTypeToken<T> extends TypeToken<List<T>> {}
    public static class TypeToken<T> {}
    public static void main (String[] args) throws java.lang.Exception  {            
        LinkTypeToken<Number> listA = null;
        TypeToken<List<Number>> listB = listA;

        LinkTypeToken<? extends Number> listC = null;
        TypeToken<? extends List<? extends Number>> listD = listC;

        // error: incompatible types: LinkTypeToken<CAP#1> cannot be 
        // converted to TypeToken<List<? extends Number>>
        // TypeToken<List<? extends Number>> listE = listC;
        //                                           ^
        // where CAP#1 is a fresh type-variable:
        //   CAP#1 extends Number from capture of ? extends Number        
        TypeToken<List<? extends Number>> listE = listC;
    }
}

导致编译错误的行之所以这样做是因为如果可以分配这些类型，则可以执行以下操作：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

class IdeoneWhy
{
    public static class ArrayListTypeToken<T> extends TypeToken<ArrayList<T>>
    {
        ArrayList<T> element = null;
        void setElement(ArrayList<T> element)
        {
            this.element = element;
        }
    }

    public static abstract class TypeToken<T>
    {
        abstract void setElement(T element);
    }

    public static void main(String[] args)
    {
        ArrayListTypeToken<? extends Number> listC = new ArrayListTypeToken<Integer>();
        TypeToken<? extends List<? extends Number>> listD = listC;

        // This is not possible:
        //TypeToken<List<? extends Number>> listE = listC;

        // But let's enforce it with a brutal cast:
        TypeToken<List<? extends Number>> listE = 
            (TypeToken<List<? extends Number>>)(Object)listC;

        // This throws a ClassCastException
        listE.setElement(new LinkedList<Integer>());
    }
}

因此TypeToken<List<? extends Number>>不可从TypeToken<? extends List<? extends Number>>进行分配这一事实实际上仅是为了防止ClassCastException。

tl; dr ：

更简单的变体是这样：

import java.util.ArrayList;
import java.util.List;

public class WhySimpler
{
    public static void main(String[] args)
    {
        List<Float> floats = new ArrayList<Float>();

        // This is not possible
        //List<Number> numbers = floats;

        // Let's enforce it with a brutal cast:
        List<Number> numbers = (List<Number>)(Object)floats;

        Integer integer = 123;

        // This is possible, because Integer is a Number: 
        numbers.add(integer);

        // Now, we ended up placing an Integer into a list that
        // may only contain Float values.
        // So this will cause a ClassCastException:
        Float f = floats.get(0);

    }
}

相反，当将类型声明为List<? extends Number>时，则可以进行赋值，因为不可能将无效的类型潜入这样的列表中：

List<Float> floats = new ArrayList<Float>();
List<? extends Number> numbers = floats;
numbers.add(someInteger); // This is not possible

长话短说：一切都与类型安全有关。

TypeToken嵌套泛型类型时发生意外的泛型行为

1 个答案: