关于Java中基类构造器的调用问题
在《java编程思想》第７章复用类中有这样一段话，值得深思。当子类继承了父类时，就涉及到了基类和导出类（子类）这两个类。从外部来看，导出类就像是一个与基类具有相同接口的新类，或许还会有一些额外的方法和域。但继承并不只是复制基类的接口。当创建一个导出类对象时，该对象包含了一个基类的子对象，这个子对象与你用基类直接创建的对象是一样的，二者区别在于，后者来自于外部，而基类的子对象是被包裹在导出类对象内部。
这就引发出了一个很重要的问题，对基类子对象的正确初始化也是至关重要的（我们可能在子类的使用基类中继承的方法和域），而且也仅有一种方法来保证这一点：在子类构造器中调用基类构造器来执行初始化。
无参的基类构造器
我们知道，当一个类你没有给他构造函数，java会自动帮你调用无参的构造器，同时java也会在导出类的构造器中插入对基类构造器的调用。下面的代码说明了这个工作机制：
//: reusing/cartoon.java
// constructor calls during inheritance.
import static net.mindview.util.print.*;
class art {
art() { print("art constructor"); }
}
class drawing extends art {
drawing() { print("drawing constructor"); }
}
public class cartoon extends drawing {
public cartoon() { print("cartoon constructor"); }
public static void main(string[] args) {
cartoon x = new cartoon();
}
} /* output:
art constructor
drawing constructor
cartoon constructor
*///:~
观察上述代码的运行结果，在创建cartoon对象时，会先调用其父类drawing的构造器，而其父类又继承自art类，所以又会调用art类的构造器，就像层层往上。虽然在其构造器中都没有显式调用其父类构造器，但是java会自动调用其父类的构造器。即使不为cartoon()创建构造器，编译器也会合成一个默认的无参构造器，该构造器将调用基类的构造器。
带参数的基类构造器
当基类中的构造器都是带有参数时，编译器就不会自动调用，必须用关键字super显式地调用基类构造器，并且传入适当的参数，相应的例子代码如下：
//: reusing/chess.java
// inheritance, constructors and arguments.
import static net.mindview.util.print.*;
class game {
game(int i) {
print("game constructor");
}
}
class boardgame extends game {
boardgame(int i) {
super(i);
print("boardgame constructor");
}
}
public class chess extends boardgame {
chess() {
super(11);
print("chess constructor");
}
public static void main(string[] args) {
chess x = new chess();
}
} /* output:
game constructor
boardgame constructor
chess constructor
*///:~
从上述代码中可以观察到，必须在子类chess构造器中显示的使用super调用父类构造器并传入适当参数。而且，调用基类构造器必须是在子类构造器中做的第一件事。
基类构造器的调用顺序问题
在此之前，我们先来探讨一下对象引用的初始化问题。在java中，类中域为基本类型时能够自动被初始化为零，但是对象引用会被初始化为null。我们往往需要在合适的位置对其进行初始化，下面是几个可以进行初始化的位置：
1.在定义对象的地方。这意味着它们总是能够在构造器被调用之前被初始化。
2.在类的构造器中。
3.就在正要使用这些对象之前，这种方式称为惰性初始化。
记住上面的第１点，下面看一个比较复杂的例子来看一下基类构造器的调用顺序问题。
// reusing/ex7/c7.java
// tij4 chapter reusing, exercise 7, page 246
/* modify exercise 5 so that a and b have constructors with arguments instead
* of default constructors. write a constructor for c and perform all
* initialization within c's constructor.
*/
import static org.greggordon.tools.print.*;
class a {
a(char c, int i) { println("a(char, int)");}
}
class b extends a {
b(string s, float f){
super(' ', 0);
println("b(string, float)");
}
}
class c7 extends a {
private char c;
private int i;
c7(char a, int j) {
super(a, j);
c = a;
i = j;
}
b b = new b("hi", 1f); // will then construct another a and then a b
public static void main(string[] args) {
c7 c = new c7('b', 2); // will construct an a first
}
}
上述这段代码输出：
a(char, int)
a(char, int)
b(string, float)
注意基类构造器、子类构造器、类的成员对象初始化的顺序：
１．在new一个类的对象时，首先调用其父类构造器(可以是无参的和有参的，无参的系统会自动调用，有参的需要自己指定)。如上述c7中的super(a, j)
２．然后执行其成员对象初始化语句，调用b类构造器，如上述中的
b b = new b("hi", 1f)，而b的构造器又会先调用基类a的构造器。
３．最后返回到c7中的构造器，继续执行c=a,i=j。