第一題：

 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 }

Java繼承中的幾道面試題