子類對父類構造方法調用小結

1、若是父類中沒有構造函數，即便用默認的構造函數，那子類的構造函數會自動調用父類的構造函數 

Java代碼  

1. class Father {      
2.   private int a, b;      
3.      
4.   void show() {      
5.     System.out.println(a);      
6.   }      
7. }      
8.      
9. class Son extends Father {      
10.   private int c, d;      
11.      
12.   Son(int c, int d) {      
13.     this.c = c;      
14.     this.d = d;      
15.   }      
16. }      
17.      
18. public class ConstructionTest {      
19.   public static void main(String args[]) {      
20.     Son s = new Son(2, 3);      
21.     s.show();      
22.   }      
23. }   

輸出結果0，說明子類的構造函數自動調用父類的無參構造函數，初始化父類的成員爲0 

2、若是父類中定義了無參構造函數，子類的構造函數會自動調用父類的構造函數 

Java代碼  

1. class Father {      
2.   private int a, b;      
3.      
4.   Father() {      
5.     System.out.println("father done");      
6.   }      
7.      
8.   void show() {      
9.     System.out.println(a);      
10.   }      
11. }      
12.      
13. class Son extends Father {      
14.   private int c, d;      
15.      
16.   Son(int c, int d) {      
17.     this.c = c;      
18.     this.d = d;      
19.   }      
20. }      
21.      
22. public class ConstructionTest {      
23.   public static void main(String args[]) {      
24.     Son s = new Son(2, 3);      
25.     s.show();      
26.   }      
27. }   
28. 輸出結果：father done    
29.   
30. 0  
31. 說明重寫了默認的無參構造函數，子類自動調用這個函數，父類的成員仍是被初始化爲0.  
32.   
33. 3、 若是定義了有參構造函數，則不會有默認無參構造函數，這樣的話子類在調用父類的無參構造函數的時候會出錯（沒有用super調用父類有參構造函數的狀況下）  
34.   
35. class Father {      
36.   private int a, b;      
37.      
38.   Father(int a, int b) {      
39.     this.a = a;      
40.     this.b = b;      
41.   }      
42.      
43.   void show() {      
44.     System.out.println(a);      
45.   }      
46. }      
47.      
48. class Son extends Father {      
49.   private int c, d;      
50.      
51.   Son(int c, int d) {      
52.     this.c = c;      
53.     this.d = d;      
54.   }      
55. }      
56.      
57. public class ConstructionTest {      
58.   public static void main(String args[]) {      
59.     Son s = new Son(2, 3);      
60.     s.show();      
61.   }      
62. }   
63. 輸出結果：  
64. Exception in thread "main" java.lang.NoSuchMethodError: Father: method <init>()V  
65. not found  
66. at Son. <init>(Son.java:5)  
67. at ConstructionTest.main(ConstructionTest.java:6)  

     實際上，在子類的每個構造函數中，都會調用父類的構造函數。調用哪個構造函數，這裏分兩種狀況： 
    （1）不顯式的用super來指定。這種狀況下，會默認的調用無參數的構造函數。若是父類中沒有無參數的構造函數，那麼程序就會出錯，就像以上那個例子。把Father類中的那個構造函數去掉，程序就能經過編譯。若是一個類中，沒有一個構造函數，那麼編譯器就會給這個類加上一個無參構造函數。 
　　（2）顯式的使用super來指定調用哪個構造函數。在Son類的構造函數中加上super(c,d)，程序也能夠經過編譯。 


另外，看以下例子： 

Java代碼  

1. A.java  
2.   
3. class A{  
4.   
5. public A(){  
6.   
7. System.out.println("A無參數構造函數被調用");  
8.   
9. }  
10.   
11. public A(int i){  
12.   
13. System.out.println("A有參數構造函數被調用");  
14.   
15. }  
16.   
17. }  
18.   
19. B.java  
20.   
21. class B extends A{  
22.   
23. public B(){  
24.   
25. }  
26.   
27. public B(int i){  
28.   
29. }  
30.   
31. }  
32.   
33. public static void main(String[] args){  
34.   
35. new B(1);  
36.   
37. }  
38.   
39. }  

　　這個程序打印：無參數的構造函數被打印。而不是：有參數的構造函數被打印。這說明你只要不使用super來指定，他就會默認的去調用父類無參數的構造函數。