class Father { int a = 100; int b = 200; public void print() { System.out.println(a + " " + b); } } class Child extends Father { int b = 300; int c = 400; public void print() { System.out.println(a + " " + b + " " + c); } public void printExtend() { System.out.println(c); } } public class Main { public static void main(String[] a) { Father obj = new Child(); System.out.println(obj.a); / AA语句 System.out.println(obj.b); // BB语句 obj.print(); // CC语句 obj.printExtend(); // DD语句 } }

这段代码会输出什么？

答案：

AA语句会输出 100，因为 Father 类的 a 变量被继承并赋值为 100，而子类 Child 中没有对 a 进行重写或者隐藏。

BB语句会输出 200，因为在 Child 类中定义了一个与父类同名的 b 变量，这个变量会隐藏父类的 b 变量，所以 obj.b 会访问到父类的 b 变量。

CC语句会输出 100 300 400，因为 obj 是一个 Father 类型的引用，但是实际引用的是 Child 类的一个对象，所以调用 print 方法时会调用 Child 类中的 print 方法，从而输出 Child 类中的 a、b、c 变量。

DD语句会编译错误，因为 Father 类中没有 printExtend 方法，而 obj 引用的类型是 Father 类型，无法调用子类中的方法。

相关问题

class Father { int a =100; public void print() { System.out.println(a); } } class Child1 extends Father { int a =200; public void print() { System.out.println(a); } } class Child2 extends Father { int a =300; public void print() { System.out.println(a); } } public class Main { public static void main(String[] a) { Father obj1; obj1=new Child1(); System.out.println(obj1.a); obj1.print(); obj1=new Child2(); System.out.println(obj1.a); obj1.print(); } }

执行代码的输出结果为：

200
200
300
300

首先定义了一个 `Father` 类型的引用变量 `obj1`，然后将其赋值为 `Child1` 类型的对象。因为 `Child1` 类是 `Father` 类的子类，所以可以将 `Child1` 类型的对象赋值给 `Father` 类型的引用变量。此时，`obj1` 引用的对象是 `Child1` 类型的，所以访问 `obj1.a` 时，会输出 `200`，而调用 `obj1.print()` 方法时，会调用 `Child1` 类中重写的 `print()` 方法，输出的结果也是 `200`。

接着，将 `obj1` 赋值为 `Child2` 类型的对象。此时，`obj1` 引用的对象变成了 `Child2` 类型的，所以访问 `obj1.a` 时，会输出 `300`，而调用 `obj1.print()` 方法时，会调用 `Child2` 类中重写的 `print()` 方法，输出的结果也是 `300`。

因此，最终输出的结果为 `200 200 300 300`。

有如下父类和子类的定义，请根据要求填写代码。 class Father { int a; public Father(int a) { this.a=a; } public void print() { System.out.println(a); } } class Child extends Father { int a; public Child(int a) { super(a); // 将形参a的数值赋给父类成员变量a a=super.a*10; // 将父类成员变量a的值*10赋给本类的成员变量a } public void print() { System.out.println（ System.out.println(super.a); ); // 输出父类成员变量a的值 System.out.println( System.out.println(a); ); // 输出子类成员变量a的值 } } public class Main { public static void main(String[] args) { Child child=new Child(10); child.print(); } }

以下是填写完整的代码：

class Father {
    int a;
    
    public Father(int a) {
        this.a = a;
    }
    
    public void print() {
        System.out.println(a);
    }
}

class Child extends Father {
    int a;
    
    public Child(int a) {
        super(a); // 将形参a的数值赋给父类成员变量a
        this.a = super.a * 10; // 将父类成员变量a的值*10赋给本类的成员变量a
    }
    
    public void print() {
        System.out.println(super.a); // 输出父类成员变量a的值
        System.out.println(a); // 输出子类成员变量a的值
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child(10);
        child.print();
    }
}

这段代码定义了一个父类 `Father` 和一个子类 `Child`。父类 `Father` 有一个整型成员变量 `a` 和一个构造函数，子类 `Child` 继承了父类 `Father` 并添加了一个整型成员变量 `a`，并重写了父类的 `print()` 方法。

在 `Main` 类的 `main()` 方法中，创建了一个 `Child` 类的对象 `child`，并调用了它的 `print()` 方法。执行结果会依次输出父类成员变量 `a` 的值和子类成员变量 `a` 的值。