我有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

最佳答案

我认为核心这个问题已经以类似的形式被问过好几次了。但我不确定，因为这是特别难以理解这个概念的星座之一。

也许人们可以这样想象:

• extendsType这里的方法返回一个 TypeToken<? extends Number>

• 在调用 list 时方法，?在类型参数 T 中捕获.这个捕获可以(粗略地说)想象成一个新的类型变量——类似于X extends Number。 , 该方法返回 TypeToken<List<X>>

• 现在 TypeToken<List<X>>不可分配给 TypeToken<List<? extends Number>> , 作为通常的约束。也许这张 table ，有<===指示可分配性和 <=/=指示不可分配性，将有助于:

                      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在这里可能再次最相关:

Super-subtype relationships among instantiations of generic types are determined by two orthogonal aspects.

On the one hand, there is the inheritance relationship between a supertype and a subtype.

...

On the other hand, there is a relationship based on the type arguments. The prerequisite is that at least one of the involved type arguments is a wildcard. For example, Collection<? extends Number> is a supertype of Collection<Long>, because the type Long is a member of the type family that the wildcard " ? extends Number " denotes.

^{我认为捕获是“新类型 X” 的想法听起来很有说服力，尽管其中涉及一些操作:这在解析过程中有些“隐式”发生，并且在代码，但我发现它在某种程度上有帮助，当我写一个 library for types所有这些问题都是从哪里来的……}

已更新以进一步详细说明，引用评论:

我提到过“按照通常的约束”类型是不可分配的。现在人们可以争论这些“约束”从何而来。但它们基本上总是有相同的原因:类型不可分配，因为如果它们是可分配的，程序就不是类型安全的。 (这意味着有可能以一种或另一种方式激发 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

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

关于java - TypeToken 嵌套泛型类型的意外泛型行为，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/52794713/