Question

我对这段代码感到有点困惑，这是一个了解参数类的测试。

我有2个类，一个是Main类，另一个是参数类。当我用Integer创建一个新的Object作为参数时，我认为构造函数会调用print（Integer x）方法，但它不是这样的，而java会调用print（Object o）方法。

有人知道为什么会这样吗？

package classi.parametriche;

public class Contenitore <E> {
public E variabile;

public Contenitore(E value){
    variabile = value;
    System.out.println("Variabilie : "+variabile.getClass().toString());
    System.out.println("Variabile : "+value.getClass().toString());
    println(variabile);
}
public void println(String s){
    System.out.println("Stringa : "+ s);
}
public void println(Integer x){
    System.out.println("Int : " + x);
}
public void println(short x){
    System.out.println("short : " + x);
}
public void println(byte x){
    System.out.println("byte : " + x);
}
public void println(long x){
    System.out.println("long : " + x);
}
public void println(char x){
    System.out.println("char : " + x);
}
public void println(float x){
    System.out.println("float : " + x);
}
public void println(double x){
    System.out.println("double : " + x);
}
public void println(Object o){
    if (o != null){
        System.out.println("Object : " + o.toString());
    }else{
        System.out.println("null");
    }
}

}

public class ClassiParametriche {
    public static void main(String[] args) {
        Contenitore<Integer> c = new Contenitore <Integer>(42);

    }
}

这是结果：

 run:
 Variabilie : class java.lang.Integer
 Variabile : class java.lang.Integer
 Object : 42

Answer 1

这是因为type erasure和编译时绑定。

编译器在编译时决定调用哪个println方法。因为类的字段是通用的，没有定义的超类，所以在类型擦除之后的剩余类型是Object。这意味着字段变量在内部作为Object处理。

您还可以查看this帖子了解详情。

Answer 2

答案是类型擦除。在运行时，类没有参数类型。 Java中的泛型纯粹是编译时的糖。编译代码后，它将失去对相关参数类型的任何了解。因此，当您将Integer传递给构造函数时，构造函数实际上需要一个java.lang.Object类型的变量

Java中的参数类

2 个答案: