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语句 } }
时间: 2024-04-21 18:30:10 浏览: 24
这段代码会输出什么?
答案:
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; 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+" "+obj.b); obj.print(); } } A. 100 200 100 200 400 B. 100 300 100 300 400 C. 100 300 100 200 400 D. 100 200 100 300 400
执行的结果是C。在 `main()` 方法中,首先创建了一个 `Child` 对象的父类引用 `Father obj`,然后将其指向 `Child` 类型的对象。
因为 `Child` 类是 `Father` 类的子类,所以可以将 `Child` 类型的对象赋值给 `Father` 类型的引用。但是,由于 `obj` 是 `Father` 类型的引用变量,所以只能访问 `Father` 类中定义的实例变量和方法,不能访问 `Child` 类中定义的实例变量和方法,除非进行类型转换。
在 `Father` 类中,有两个实例变量 `a` 和 `b`,它们的值分别是 `100` 和 `200`。在 `Child` 类中,有一个实例变量 `b` 和一个实例变量 `c`,它们的值分别是 `300` 和 `400`。由于 `obj` 引用的是 `Child` 类型的对象,因此可以调用 `Child` 类中重写的 `print()` 方法,该方法输出的是 `a`、`b` 和 `c` 三个实例变量的值。
因此,在执行 `obj.print()` 语句时,输出的结果是 `100 300 400`。在执行 `System.out.println(obj.a+" "+obj.b)` 语句时,输出的结果是 `100 200`,因为 `obj` 是 `Father` 类型的引用,所以访问的是 `Father` 类中的实例变量 `a` 和 `b`。因此,最终输出的结果是 `100 200 100 200 400`。
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`。