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

Question

我试图在下面的代码 sn-p 中打印整数值，但每次它都会打印 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，而不是 integer？

Answer 1

您的问题有一个简单的答案。我将证明每种情况的输出，然后是解决方案。在此之前，关于您的代码 sn-p 的一些说明：

• 作为B 类扩展A，并具有相同的方法methodOne 和不同类型的参数（Integer），它有两个重载版本的方法methodOne。
• A a = new B(); 这里，a 是 B 和 A 类型的实例化。

理由：

1. a.methodOne(10)：参数10的类型为int。因此，A 类的 void methodOne(int i) 被调用。
2. a.methodOne(new Integer(10))：参数new Integer(10) 的类型是Integer，但子类B 中的方法methodOne(Integer i) 对a 不可见。因此new Integer(10) 被拆箱为int 10 并再次调用A 类的void methodOne(int i)。
3. b.methodOne(20)：由于b 是B 的实例化，它具有方法methodOne 的两个版本。但是参数10 的类型是int，因此再次调用了A（其父类）类的void methodOne(int i)。

解决办法：

B b = new B();
b.methodOne(new Integer(20));

这里，参数20的类型是Integer。所以B类的void methodOne(Integer i)被调用了。

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

// Place this method in Class B
void test(){

}

//In the main method
A a = new B();
// a.test();  
// The test method will not be available in class `A`, though the instantation of `a` is of type `B`.

Answer 2

该行为与自动装箱和自动拆箱有关。由于这两种情况的通用行，请注意此示例不与方法覆盖相关。

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 3

B 类扩展了 A 类，因此它还包含 A 类的方法。

这就是为什么，当你调用methodOne()时，你会从B类中调用A类的methodOne()，因为A类是主类，B类是A类的子类。所以，首先采用 A 类，这就是它从 A 类的 methodOne() 打印“int”而不是从 B 类的 methodOne() 打印“Integer”的原因。

解决方案：- 将 Class 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);
    }
}