Java继承中的几道面试题

 1 /*
 2     看程序写结果：
 3         A:访问成员变量的原则：就近原则。
 4         B:this和super的问题：
 5             this     访问本类的成员
 6             super    访问父类的成员(可以理解为的)
 7         C:子类的所有构造方法执行前默认先执行父类的无参构造方法。
 8         D:一个类的初始化过程：
 9             成员变量进行初始化过程如下：
10                 默认初始化
11                 显示初始化
12                 构造方法初始化
13                 
14     输出的结果是：
15         　　　　fu
16         　　　　zi
17         　　　　30
18         　　　　20
19         　　　　10
20 */
21 class Fu {
22     public int num = 10;
23     public Fu() {
24         System.out.println("fu");
25     }
26 }
27 
28 class Zi extends Fu {
29     public int num = 20;
30     public Zi() {
31         System.out.println("zi");
32     }
33     public void show() {
34         int num = 30;
35         System.out.println(num); //30
36         System.out.println(this.num); //20
37         System.out.println(super.num); //10
38     }
39 }
40 class ExtendsTest {
41     public static void main(String[] args) {
42         Zi z = new Zi();
43         z.show();
44     }
45 }

 1 /*
 2     看程序写结果：
 3         A:一个类的静态代码块,构造代码块,构造方法的执行流程：
 4             静态代码块 > 构造代码块 > 构造方法
 5         B:静态的内容是随着类的加载而加载，
 6             即：静态代码块的内容会优先执行。
 7         C:构造代码块
 8 　            在类中方法外出现(即在类中的成员位置)，可以把多个构造方法方法中相同的代码存放到一起，用于对对象进行初始化，
 9             每次调用构造方法都执行，并且在构造方法前执行。
10         C:子类的所有的构造方法默认都会去访问父类的无参构造方法。
11         
12     输出结果是：
13         　　静态代码块Fu
14         　　静态代码块Zi
15         　　构造代码块Fu
16         　　构造方法Fu
17         　　构造代码块Zi
18        　　 构造方法Zi
19 */
20 class Fu {
21     static {
22         System.out.println("静态代码块Fu");
23     }
24 
25     {
26         System.out.println("构造代码块Fu");
27     }
28 
29     public Fu() {
30         System.out.println("构造方法Fu");
31     }
32 }
33 
34 class Zi extends Fu {
35     static {
36         System.out.println("静态代码块Zi");
37     }
38 
39     {
40         System.out.println("构造代码块Zi");
41     }
42 
43     public Zi() {
44         System.out.println("构造方法Zi");
45     }
46 }
47 
48 class ExtendsTest2 {
49     public static void main(String[] args) {
50         Zi z = new Zi();
51     }
52 }

 1 /*
 2     看程序写结果：
 3         A:成员变量的问题
 4             int x = 10; //成员变量x是基本类型
 5             Student s = new Student(); //成员变量s是引用类型
 6         B:一个类的初始化过程
 7             先进行成员变量的初始化：
 8                 默认初始化
 9                 显示初始化
10                 构造方法初始化
11         C:子父类的初始化(分层初始化)
12             先进行父类初始化，然后进行子类初始化。
13             
14     结果：
15         YXYZ
16         
17     问题：
18         虽然子类中的构造方法默认有一个 super();
19         但初始化的时候，不是按照那个顺序进行的。
20         而是按照分层初始化进行的。
21         super(); 它仅仅表示要先初始化父类数据，再初始化子类数据。
22 */
23 
24 class X {
25     //成员变量(引用类型)
26     Y b = new Y();
27     //无参构造方法
28     X() {
29         System.out.print("X");
30     }
31 }
32 
33 class Y {
34     //无参构造方法
35     Y() {
36         System.out.print("Y");
37     }
38 }
39 
40 public class Z extends X {
41     //成员变量(引用类型)
42     Y y = new Y();
43     //无参构造方法
44     Z() {
45         //super(); //它仅仅表示要先初始化父类数据，再初始化子类数据。
46         System.out.print("Z");
47     }
48     public static void main(String[] args) {
49         new Z(); 
50     }
51 }