为什么“t instanceof T”是当 T 是类型参数且 t 是变量时不允许？

Question

Eclipse 表示，由于泛型类型擦除器，类型参数不允许进行 instanceof 操作。

我同意在运行时，不会保留任何类型信息。但请考虑以下类的通用声明：

class SomeClass<T>{
    T t;
    SomeClass(Object o){
        System.out.println(o instanceof T);   // Illegal
    }   
}        

在运行时，不会出现 T！但是如果我实例化这个Integer类型的类，那么对应的对象就会有一个Integer类型的字段t。

那么，为什么我不能用 T 检查变量的类型，在运行时可以用 Integer 替换它。我实际上会做类似“o instanceof Integer”的事情。

在什么情况下，允许带有类型参数的instanceof会引起麻烦而被禁止？

Answer 1

但是如果我实例化这个 Integer 类型的类，那么
相应的对象将有一个 Integer 类型的字段 t

不，不会。它将有一个对象类型的字段。只是每次访问它时，它都会被转换为整数。

考虑以下代码：

SomeClass<Integer> c = new SomeClass<Integer>();
SomeClass untyped = (SomeClass)c; // Which type was it?
SomeClass<String> stringTyped = (SomeClass<String>)untyped; // Now it's STRING??

有效。给你一堆编译器警告，但有效。因为字段 T 实际上是 Object 类型，并且可以转换为任何类型。

Answer 2

如果运行时需要T，则需要在运行时提供它。这通常通过传递 Class来完成。 T 必须是哪个。

class SomeClass<T> {
    final T t;

    public SomeClass(Class<T> tClass, T t) {
        if(!tClass.isAssignableFrom(t.getClass()) throw new IllegalArgumentException("Must be a " + tClass);
        this.t = t;
    }

    private SomeClass(T t) {
        this.t = t;
    }

    public static <T> SomeClass<T> of(Class<T> tClass, T t) {
        if(!tClass.isAssignableFrom(t.getClass()) throw new IllegalArgumentException("Must be a " + tClass);
        return new SomeClass(t);
    }
} 

// doesn't compile
SomeClass<Integer> intSomeClass = SomeClass.of(Integer.class, "one");

Class clazz = Integer.class;
// compiles with a warning and throws an IAE at runtime.
SomeClass<Integer> intSomeClass = (SomeClass<Integer>) SomeClass.of(clazz, "one");

// compiles and runs ok.
SomeClass<Integer> intSomeClass = SomeClass.of(Integer.class, 1);

Answer 3

编译语句o instanceof T后将是o instanceof Object并且因为所有类型都派生自Object，所以它的计算结果将始终为true。允许此类测试会给出假阳性结果

Answer 4

由于类型擦除，这永远不会起作用。在运行时，您只知道您的类有一个类型参数 T，但不知道它对于给定实例是哪种类型。所以你一开始就无法确定一个对象是否是T类型，因为你不知道T是什么，而不是因为它会引起某种麻烦。

如果您需要执行此类运行时检查，请将类型标记显式传递给您的对象：

SomeClass(Object o, Class<T> type) {
    System.out.println(type.isInstance(o));
}

Answer 5

但是如果我实例化这个Integer类型的类，那么对应的对象就会有一个Integer类型的字段t。

事实上，不会。它有一个 Object 类型的字段 t。正如您所说，泛型几乎完全是语法糖（例外是，当您扩展泛型类并指定类型参数时，该类型仍作为类文件中的元数据）。

Answer 6

泛型类型参数在运行时是未知的，因此没有可以比较的类。 T 仅在编译时才知道。泛型只会帮助开发人员更轻松地编写代码。但在运行时，参数只是 Object 实例。

Answer 7

Java使用“Erasure”来实现泛型，它可以在“COMPILE TIME”中检查类型并删除类型参数信息，在“RUN TIME”中只会有<类型参数的strong>BOUNDARIES，因此不会出现“Integer”之类的内容