Question

我试图在下面的代码片段中打印Integer值，但是每次它都会打印int块时。为什么会这样？

class A {
    void methodOne(int i) {
        System.out.println("int " + i);
    }
}

class B extends A {
    void methodOne(Integer i) {
        System.out.println("Integer " + i);
    }
}

public class Solution {
    public static void main(String[] args) {
        A a = new B();
        a.methodOne(10);
        a.methodOne(new Integer(10));
        B b = new B();
        b.methodOne(20);
    }
}

输出：

int 10
int 10
int 20

为什么总是打印int而不是整数？

Answer 1

该行为与“自动装箱”和“自动拆箱”有关。具有这两种情况的共同之处，请注意，此示例与方法覆盖 不相关。

A a = new B();
a.methodOne(10); /* line 1 */
a.methodOne(new Integer(10)); /* line 2 */
B b = new B();
b.methodOne(20); /* line 3 */
b.methodOne(new Integer(20)); /* line 4 */

方案1：

class A {
    void methodOne(Integer i) {
        System.out.println("Integer " + i);
    }
}

class B extends A {
    void methodOne(int i) {
        System.out.println("int " + i);
    }
}

输出

Integer 10 /* line 1, [AutoBoxing] */
Integer 10 /* line 2 */
int 20     /* line 3, B has method(int) */
Integer 20 /* line 4, B has method(Integer) */

场景2

class A {
    void methodOne(int i) {
        System.out.println("int " + i);
    }
}

class B extends A {
    void methodOne(Integer i) {
        System.out.println("Integer " + i);
    } 
}

输出

int 10     /* line 1 */
int 10     /* line 2, [auto unboxing] */
int 20     /* line 3 */
Integer 20 /* line 4 */

Answer 2

您的问题有一个简单的答案。在解决方案之后，我将说明每种情况下的输出。在此之前，有关您的代码段的一些注意事项：

由于类B扩展了A，并且具有相同的方法methodOne和不同类型的参数（Integer），因此它具有方法{{ 1}}。
methodOne在这里，A a = new B();是a且类型为B的实例。

理由：

A：参数a.methodOne(10)的类型为10。因此，将调用类int的{{1}}。
void methodOne(int i)：参数A的类型为a.methodOne(new Integer(10))，但是new Integer(10)子类Integer中的方法methodOne(Integer i)不可见。因此，B被取消装箱到a，然后再次调用类new Integer(10)的{{1}}。
int 10：由于void methodOne(int i)是A的实例，因此它具有方法b.methodOne(20)的两个版本。但是参数b的类型为B，因此再次调用类methodOne（其父类）的10。

解决方案：

int

在这里，参数void methodOne(int i)的类型为A。因此，将调用类B b = new B(); b.methodOne(new Integer(20));的{{1}}。

这里有一个小实验，可以帮助您了解父类中子类方法的不可见性。在类B中放置一个伪方法，并尝试使用类型为20的对象但类型为Integer的对象进行访问。以下是修改后的代码。

void methodOne(Integer i)

Answer 3

B类扩展了A类，由于这个原因，它也包含A类的方法。

这就是为什么，当您调用methodOne（）时，会从Class B中调用Class A的methodOne（），因为Class A是主要类，而Class B是Class A的子类。首先采用类A，这就是为什么它从类A的methodOne（）中打印“ int”而不是从类B的methodOne（）中复制“整数”的原因。

解决方案：- 将B类的methodOne（）重命名为“ methodTwo（）”或任何其他名称，然后在要打印“ Integer”的位置调用该方法。

Answer 4

class A {
    void methodOne(Integer i) {
        System.out.println("Integer " + i);
    }
}

class B extends A {
    void methodOne(int i) {
        System.out.println("int " + i);
    }
}

public class Solution {
    public static void main(String[] args) {
        A a = new B();
        a.methodOne(10);
        a.methodOne(10);
        B b = new B();
        b.methodOne(20);
    }
}

为什么父子关系中的int和Integer总是在java中打印int？

4 个答案: