java - 为什么这会强制转换为泛型类型参数？

Question

对类型删除有所了解，我会想 this cast不会在运行时编译或工作:

public class GenericDatumReader<D> implements DatumReader<D> {
    ...
    @SuppressWarnings("unchecked")
    public D read(D reuse, Decoder in) throws IOException {
      return (D) read(reuse, actual, expected != null ? expected : actual, in);
    }

但是，它有效!

程序如何在运行时知道 D 是什么？

编辑

我写了一个简单的测试:

  1 public class Main {                                                                                                                                                           
  2                                                                                                                                                                               
  3     public static class Something<D> {                                                                                                                                        
  4                                                                                                                                                                               
  5         private Object getObj() { return new Object(); }                                                                                                                      
  6         private String getStr() { return new String("hello"); }                                                                                                               
  7                                                                                                                                                                               
  8         public <D> D get(boolean str) {                                                                                                                                       
  9            return (D) (str ? getStr() : getObj());                                                                                                                            
 10         }                                                                                                                                                                     
 11     }                                                                                                                                                                         
 12                                                                                                                                                                               
 13     public static void main(String[] args) {                                                                                                                                  
 14         Something<String> something = new Something<>();                                                                                                                      
 15         String str = something.get(true);                                                                                                                                     
 16         String notStr = something.get(false);                                                                                                                                 
 17     }                                                                                                                                                                         
 18 } 

如果没有 (D) 转换，则无法编译:

Main.java:9: error: incompatible types: bad type in conditional expression
           return (str ? getStr() : getObj());
                               ^
    String cannot be converted to D
  where D is a type-variable:
    D extends Object declared in method <D>get(boolean)
Main.java:9: error: incompatible types: bad type in conditional expression
           return (str ? getStr() : getObj());
                                          ^
    Object cannot be converted to D
  where D is a type-variable:
    D extends Object declared in method <D>get(boolean)
2 errors

使用 (D) 转换我只得到一个未经检查的警告，但它编译。但是，在运行时:

$ java Main
Exception in thread "main" java.lang.ClassCastException: java.lang.Object cannot be cast to java.lang.String
        at Main.main(Main.java:16)

Answer 1

这里有两个方面:

1. 编译时:这是有效的，因为在编译时你对 D 的唯一了解是它是一个 Object，所以返回值很可能是实际上将成为 D——编译器无法确定。
2. 运行时:因为 Java 通过删除实现泛型，所以泛型类型几乎完全是一个编译时概念。该方法在运行时实际上并不知道 D 是什么，因此转换根本不做任何事情。如果非泛型方法将结果分配给运行时已知的某种类型(即非泛型)，那么如果对象的类型不正确，它可能会创建强制转换异常。