第七章-复用类-继承语法-2初始化基类-不带参构造器

练习5：（1）创建带有两个默认构造器（空参数列表）的类A和类B。从A中继承产生一个名为C的新类，并在C内创建一个B类的成员。不要给C编写构造器。创建一个C类的对象并观察其结果。

一：我的答案

我的理解：A类 继承 C类，

package com.learnJava.test;

/**
 * @Author zhuchangli
 * @Date 2019/9/14
 **/

class ArtA{
    ArtA(){
        System.out.println("A constructor");
    }
}

class ArtB {
    ArtB(){
        System.out.println("B constructor");
    }
}

public class CartoonC extends ArtA{
    public static void main(String [] args){
        ArtB b  = new ArtB();
    }

}

二：参考答案

package com.learnJava.test;

/**
 * @Author zhuchangli
 * @Date 2019/9/14
 **/

class ArtA{
    ArtA(){
        System.out.println("A constructor");
    }
}

class ArtB extends ArtA{
    ArtB(){
        System.out.println("B constructor");
    }
}

public class CartoonC extends ArtA{
    public static void main(String [] args){
        ArtB b  = new ArtB();
    }

}

我的答案里面没有 B继承A，答案更能说明继承关系

三：

练习4：证明基类构造器：（a）总是会被调用；（b）在导出类构造器之前被调用。

参考答案，太菜没有给出自己的答案。

package com.learnJava.test;

/**
 * @Author zhuchangli
 * @Date 2019/9/14
 **/

class A {
    A(){
        System.out.println("A() ");
    }
}
class B extends A{
    B(){
        System.out.println("B() ");
    }
}

class C extends B{
    C(){
        System.out.println("C()");
    }
}

class D extends C{
    D(){
        System.out.println("D()");
    }
    public static D makeD(){
        return new D();
    }

   public static void main(String [] args){
        D d = new D();
        D d2 = makeD();
    }
}

public class E extends D{
    E(){
        System.out.println("E()");
    }
    public static void main(String [] args){
        E e = new E();
        D.main(args);
    }
}

留有疑问：

我觉得运行结果是：A（） B（） C（）D（）E（） A（）B（）C（）D（）

但实际编译器运行结果为：

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

加在E类上的断点 未走到，直接从D类开始，有点儿奇怪。

练习3：

先看下面这段代码

package com.learnJava.test;

/**
 * @Author zhuchangli
 * @Date 2019/9/14
 **/

class Art{
    Art(){
        System.out.println("Art constructor");
    }
}

class Drawing extends Art{
    Drawing(){
        System.out.println("Drawing constructor");
    }
}
public class Cartoon extends Drawing{
    public Cartoon(){
        System.out.println("Cartoon constructor");
    }

    public static void main(String [] args){
        Cartoon x = new Cartoon();
    }
}

运行结果为：

Art constructor
Drawing constructor
Cartoon constructor

书上结论为：构造过程是从基类“向外”扩散的，所以基类在导出类构造器可以访问它之前，就会完成初始化，即使你不为Cartoon() 创建构造器，编译器也会为你合成一个默认的构造器，该构造器将调用基类构造器。

练习3：证明前面这句话。

我的答案是：

package com.learnJava.test;

/**
 * @Author zhuchangli
 * @Date 2019/9/14
 **/

class Art{
    Art(){
        System.out.println("Art constructor");
    }
}

class Drawing extends Art{
    Drawing(){
        System.out.println("Drawing constructor");
    }
}
public class Cartoon extends Drawing{
   /* public Cartoon(){
        System.out.println("Cartoon constructor");
    }*/

    public static void main(String [] args){
        Cartoon x = new Cartoon();
    }
}

运行结果：

Art constructor
Drawing constructor

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