第七章-複用類-繼承語法-2初始化基類-不帶參構造器

練習5：（1）建立帶有兩個默認構造器（空參數列表）的類A和類B。從A中繼承產生一個名爲C的新類，並在C內建立一個B類的成員。不要給C編寫構造器。建立一個C類的對象並觀察其結果。

一：個人答案

個人理解：A類 繼承 C類，

 1 package com.learnJava.test;
 2 
 3 /**
 4  * @Author zhuchangli
 5  * @Date 2019/9/14
 6  **/
 7 
 8 class ArtA{
 9     ArtA(){
10         System.out.println("A constructor");
11     }
12 }
13 
14 class ArtB {
15     ArtB(){
16         System.out.println("B constructor");
17     }
18 }
19 
20 public class CartoonC extends ArtA{
21     public static void main(String [] args){
22         ArtB b  = new ArtB();
23     }
24 
25 }

二：參考答案

 1 package com.learnJava.test;
 2 
 3 /**
 4  * @Author zhuchangli
 5  * @Date 2019/9/14
 6  **/
 7 
 8 class ArtA{
 9     ArtA(){
10         System.out.println("A constructor");
11     }
12 }
13 
14 class ArtB extends ArtA{
15     ArtB(){
16         System.out.println("B constructor");
17     }
18 }
19 
20 public class CartoonC extends ArtA{
21     public static void main(String [] args){
22         ArtB b  = new ArtB();
23     }
24 
25 }

個人答案裏面沒有 B繼承A，答案更能說明繼承關係

三：

練習4：證實基類構造器：（a）老是會被調用；（b）在導出類構造器以前被調用。

參考答案，太菜沒有給出本身的答案。

 1 package com.learnJava.test;
 2 
 3 /**
 4  * @Author zhuchangli
 5  * @Date 2019/9/14
 6  **/
 7 
 8 class A {
 9     A(){
10         System.out.println("A() ");
11     }
12 }
13 class B extends A{
14     B(){
15         System.out.println("B() ");
16     }
17 }
18 
19 class C extends B{
20     C(){
21         System.out.println("C()");
22     }
23 }
24 
25 class D extends C{
26     D(){
27         System.out.println("D()");
28     }
29     public static D makeD(){
30         return new D();
31     }
32 
33    public static void main(String [] args){
34         D d = new D();
35         D d2 = makeD();
36     }
37 }
38 
39 public class E extends D{
40     E(){
41         System.out.println("E()");
42     }
43     public static void main(String [] args){
44         E e = new E();
45         D.main(args);
46     }
47 }

留有疑問：

我以爲運行結果是：A（） B（） C（）D（）E（） A（）B（）C（）D（）

但實際編譯器運行結果爲：

A()
B()
C()
D()
A()
B()
C()
D()

加在E類上的斷點 未走到，直接從D類開始，有點兒奇怪。

練習3：

先看下面這段代碼

 1 package com.learnJava.test;
 2 
 3 /**
 4  * @Author zhuchangli
 5  * @Date 2019/9/14
 6  **/
 7 
 8 class Art{
 9     Art(){
10         System.out.println("Art constructor");
11     }
12 }
13 
14 class Drawing extends Art{
15     Drawing(){
16         System.out.println("Drawing constructor");
17     }
18 }
19 public class Cartoon extends Drawing{
20     public Cartoon(){
21         System.out.println("Cartoon constructor");
22     }
23 
24     public static void main(String [] args){
25         Cartoon x = new Cartoon();
26     }
27 }

運行結果爲：

Art constructor
Drawing constructor
Cartoon constructor

書上結論爲：構造過程是從基類「向外」擴散的，因此基類在導出類構造器能夠訪問它以前，就會完成初始化，即便你不爲Cartoon() 建立構造器，編譯器也會爲你合成一個默認的構造器，該構造器將調用基類構造器。

練習3：證實前面這句話。

個人答案是：

 1 package com.learnJava.test;
 2 
 3 /**
 4  * @Author zhuchangli
 5  * @Date 2019/9/14
 6  **/
 7 
 8 class Art{
 9     Art(){
10         System.out.println("Art constructor");
11     }
12 }
13 
14 class Drawing extends Art{
15     Drawing(){
16         System.out.println("Drawing constructor");
17     }
18 }
19 public class Cartoon extends Drawing{
20    /* public Cartoon(){
21         System.out.println("Cartoon constructor");
22     }*/
23 
24     public static void main(String [] args){
25         Cartoon x = new Cartoon();
26     }
27 }

運行結果：

Art constructor
Drawing constructor

和參考答案差很少，這裏就不貼參考答案了。