Question

请运行以下两个程序的输出......

节目1：

package p1;

class x {
    public void methodA() {
        System.out.println("Methos A of Class X");

    }
}

class y extends x {
    public void methodA() {
        System.out.println("Method A of Class Y");
    }
}

class Override1 {
    public static void main(String[] args) {
        x obj1 = new x();
        x obj2 = new y();
        y obj3 = new y();
        /* y obj4 = new x(); */

        obj1.methodA();
        obj2.methodA();
        obj3.methodA();
        /* obj4.methodA(); */
    }
}

Program_2：

class x {
    int a[] = new int[2];

    x() {
        a[0] = 10;
        a[1] = 20;
    }

}

class y extends x {
    int a[] = new int[10];

    y() {
        a[0] = 12000;
        a[1] = 1000;
        a[2] = 120;
    }

}

class Override2 {
    public static void main(String[] args) {
        x obj1 = new x();
        x obj2 = new y();
        // y obj3 = new x();
        y obj4 = new y();
        System.out.println(obj1.a[1]);
        System.out.println(obj2.a[1]);
        System.out.println(obj4.a[1]);

    }
}

我的具体问题是，在Program_1中，类别Y 的 MethodA 被调用了什么？并在program_2中通过什么方式调用类X 的 '20'（a [1]）？

请清楚我关于创建关于记忆分配和参考分配的对象的基本概念。

Answer 1

简短的回答是Java中没有数据多态性。

在第一个示例中，methodA与在不同类中实现的方法相同。

在第二个示例中，两个a是完全独立的，不相关的数据成员（即使它们碰巧具有相同的名称和数据类型）。

第二个例子相当于：

class x {
    int a_x[] = new int[2];
    x() {
        a_x[0] = 10; a_x[1] = 20; 
    }

}
class y extends x {
    int a_y[] = new int[10];
    y() {
        a_y[0] = 12000; a_y[1] = 1000; a_y[2] = 120;
    }
}

class Override2 {
    public static void main(String[] args) {
        x obj1 = new x();
        x obj2 = new y();
        y obj4 = new y();
        System.out.println(obj1.a_x[1]);
        System.out.println(obj2.a_x[1]);
        System.out.println(obj4.a_y[1]);
    }
}

Answer 2

我的具体问题是，在Program_1中，通过什么方式调用Y类的方法？ - ＆gt;它被称为动态调度机制（方法覆盖）。检查here。这里，无论LHS（子/父）上的引用如何，都会调用RHS（实例类型）的方法，前提是父类定义了相同的方法。

什么意思＆＃39; 20＆＃39; （a [1]）类X被称为 - ＆gt;取决于参考的类型。如果引用是X，则x.field被称为RHS的无效。

为什么在两个程序之下提供概念上不同的输出

2 个答案: