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

一、如果父類中沒有構造函數,即使用默認的構造函數,那子類的構造函數會自動調用父類的構造函數 
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(23);      
  21.     s.show();      
  22.   }      
  23. }   

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

二、如果父類中定義了無參構造函數,子類的構造函數會自動調用父類的構造函數 

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(23);      
  25.     s.show();      
  26.   }      
  27. }   
  28. 輸出結果:father done    
  29.   
  30. 0  
  31. 說明重寫了默認的無參構造函數,子類自動調用這個函數,父類的成員還是被初始化爲0.  
  32.   
  33. 三、 如果定義了有參構造函數,則不會有默認無參構造函數,這樣的話子類在調用父類的無參構造函數的時候會出錯(沒有用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(23);      
  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來指定,他就會默認的去調用父類無參數的構造函數。 
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章