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

书上代码示例：

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

结论：如果不在BoardGame() 中调用基类构造器，编译器将抱怨无法找到符合Game() 形式的构造器。

练习6：用Chess.java 来证明前一段话。

注释掉：BoardGame 类中的super(i) 即可证明。

练习7：（1）修改练习5，使A和B以带参数的构造器取代默认构造器，为C写一个构造器，并在其中执行所有的初始化。

我的答案：

package com.learnJava.test;

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

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

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

public class CartoonC extends ArtB{
    CartoonC(int i){
        super(i);
        System.out.println("C constructor");
    }
    public static void main(String [] args){
        //ArtB b  = new ArtB(10);
        CartoonC c = new CartoonC(10);
    }

}

参考答案：

 1 package com.learnJava.test;
 2
 3 /**
 4  * @Author zhuchangli
 5  * @Date 2019/9/14
 6  **/
 7 class A7{
 8     A7(char c,int i){
 9         System.out.println("A7(char,int)");
10     }
11 }
12
13 class B7 extends A7{
14     B7(String d,float j){
15         super(‘ ‘,10);
16         System.out.println("B7(String,j)");
17     }
18 }
19
20 public class C7 extends A7{
21     private char c;
22     private int j;
23     C7(char a,int i){
24         super(a,i);
25         c = a;
26         j = i;
27     }
28
29     B7 b7 = new B7("hi",0.7f);
30     public static void main(String [] args){
31         C7 c7 = new C7(‘a‘,100);
32     }
33 }

我未知的是：可以在 C7类中 定义B7 类和 初始化。而C7类和B7类都是继承的是 A7。

练习8：（1）创建一个基类，它仅有一个非默认的构造器；再创建一个导出类，它带有默认构造器和非默认构造器。在导出类的构造器中调用基类构造器。

参考答案：

 1 package com.learnJava.test;
 2
 3 /**
 4  * @Author zhuchangli
 5  * @Date 2019/9/14
 6  **/
 7
 8 class A8{
 9     private char a;
10     private int i ;
11     A8(char c,int j){
12          a = c;
13          i = j;
14          System.out.println("A8(char,int)");
15     }
16 }
17
18 public class C8 extends A8{
19     private char ch;
20     private int k;
21     C8(){
22        super(‘z‘, 0);
23         System.out.println("C8()");
24     }
25     C8(char a,int i){
26         super(a,i);
27         ch = a;
28         k = i;
29         System.out.println("C8(char,int)");
30     }
31
32     public static void main(String [] args){
33         C8 c8 = new C8();
34         C8 c81 = new C8(‘a‘,100);
35     }
36 }

未知点：在C8（），默认构造方法中不知道该如何调用基类方法。

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