调用 Java 泛型方法

java generics type-erasure generic-method

2022-09-01 14:30:39

我正在研究Java泛型特性，我不确定如何在以下方法中解释第三行：main

public class Example4 {
    public static void main(final String[] args) {
        System.out.println(Util.<String>compare("a", "b"));
        System.out.println(Util.<String>compare(new String(""), new Long(1)));
        System.out.println(Util.compare(new String(""), new Long(1)));
    }
}

class Util {
    public static <T> boolean compare(T t1, T t2) {
        return t1.equals(t2);
    }
}

第一行编译、运行并返回（如预期的那样）。false

第二行未按预期编译，因为我显式混合了和。StringLong

第三行编译，运行并返回false，但我不确定它是否理解它是如何工作的：编译器/ JVM是否将参数类型实例化为？（另外，有没有办法获得这种声明类型的 are 运行时？TObjectT

谢谢。

答案 1

的共享继承类型是。StringLongObject

当您运行此函数时，编译器希望找到两个字符串输入，并在没有找到时给出错误。但是，在不运行它的情况下运行它会导致使用最接近的共享继承类型 - 在本例中为 .Util.<String>compare(<String>Object

因此，当接受和时，它们已被转换为，并且代码运行良好。comparet1t2Object

若要在运行时获取实际类型，请使用与任何其他对象相同的技术：从类继承的。getClass()Object

答案 2

答案似乎超出了@Telthien和@newacct的答案。我很好奇自己“看到”了以下两者的区别：

System.out.println(Util.<String>compare("a", "b"));

使用显式键入，以及：

System.out.println(Util.compare(new String(""), new Long(1)));

使用隐式键入。

我进行了几次实验，使用了前两行的变体。这些实验表明，除了使用匿名/本地类技巧之外，编译器确实在编译期间检查类型，但生成的字节码仅引用，即使在第一行的情况下也是如此。Object

下面的代码段表明，即使在显式类型参数的情况下，也可以安全地执行类型转换。Object<String>

public final class Example44 {
    public static void main(final String[] args) {
        System.out.println(new Util44<String>().compare("a", "b"));
        System.out.println(new Util44().compare(new String(""), new Long(1)));
    }
}

final class Util44<T> {
    private T aT;
    public boolean compare(T t1, T t2) {
        System.out.println(this.aT);
        // I was expecting the second and third assignments to fail
        // with the first invocation because T is explicitly a String
        // and then to work with the second invocation because I use
        // a raw type and the compiler must infer a common type for T.
        // Actually, all these assignments succeed with both invocation. 
        this.aT = (T) new String("z");
        this.aT = (T) new Long(0);
        this.aT = (T) new Object();
        return t1.equals(t2);
    }
}

该方法的字节码如下所示：main

  // Method descriptor #15 ([Ljava/lang/String;)V
  // Stack: 7, Locals: 1
  public static void main(java.lang.String[] args);
     0  getstatic java.lang.System.out : java.io.PrintStream [16]
     3  new ca.polymtl.ptidej.generics.java.Util44 [22]
     6  dup
     7  invokespecial ca.polymtl.ptidej.generics.java.Util44() [24]
    10  ldc <String "a"> [25]
    12  ldc <String "b"> [27]
    14  invokevirtual ca.polymtl.ptidej.generics.java.Util44.compare(java.lang.Object, java.lang.Object) : boolean [29]
    17  invokevirtual java.io.PrintStream.println(boolean) : void [33]
    20  getstatic java.lang.System.out : java.io.PrintStream [16]
    23  new ca.polymtl.ptidej.generics.java.Util44 [22]
    26  dup
    27  invokespecial ca.polymtl.ptidej.generics.java.Util44() [24]
    30  new java.lang.String [39]
    33  dup
    34  ldc <String ""> [41]
    36  invokespecial java.lang.String(java.lang.String) [43]
    39  new java.lang.Long [46]
    42  dup
    43  lconst_1
    44  invokespecial java.lang.Long(long) [48]
    47  invokevirtual ca.polymtl.ptidej.generics.java.Util44.compare(java.lang.Object, java.lang.Object) : boolean [29]
    50  invokevirtual java.io.PrintStream.println(boolean) : void [33]
    53  return
      Line numbers:
        [pc: 0, line: 24]
        [pc: 20, line: 25]
        [pc: 53, line: 26]
      Local variable table:
        [pc: 0, pc: 54] local: args index: 0 type: java.lang.String[]

实际上，所有调用始终是具有正式参数类型的方法，这是有道理的，如另一个问题/答案中所述。为了说明这一点，编译器始终使用生成的字节码，无论是否存在显式类型参数（第一行）或隐式类型参数，但对象可以具有与不同的公共超类。ObjectObjectObject