第七章-复用类-继承语法-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

和参考答案差不多，这里就不贴参考答案了。

原文地址：https://www.cnblogs.com/changlili/p/11520049.html