构造函数的问题

缺省构造函数的问题：base类是父类，derived类是子类，首先要
说明的是由于先有父类后有子类，所以生成子类之前要首先有父类。
class是由class的构造函数constructor产生的，每一个class都有
构造函数，如果你在编写自己的class时没有编写任何构造函数，那么
编译器为你自动产生一个缺省default构造函数。这个default构造函数
实质是空的，其中不包含任何代码。但是一牵扯到继承，它的问题就出现
了。

如果父类base class只有缺省构造函数，也就是编译器自动为你产生的。
而子类中也只有缺省构造函数，那么不会产生任何问题，因为当你试图产生
一个子类的实例时，首先要执行子类的构造函数，但是由于子类继承父类，
所以子类的缺省构造函数自动调用父类的缺省构造函数。先产生父类的实例，
然后再产生子类的实例。如下：

class base{
}
class derived extends base{
public static void main(String[] args){
derived d=new derived();
}
}

下面我自己显式地加上了缺省构造函数：

class base{ 
base(){ 
System.out.println("base constructor"); 
} 
} 
class derived extends base{ 
derived(){ 
System.out.println("derived constructor"); 
} 
public static void main(String[] args){ 
derived d=new derived(); 
} 
} 

执行结果如下：说明了先产生base class然后是derived class。
base constructor


derived constructor

我要说明的问题出在如果base class有多个constructor
而derived class也有多个constructor,这时子类中的构造函数缺省
调用那个父类的构造函数呢？答案是调用父类的缺省构造函数。
但是不是编译器自动为你生成的那个缺省构造函数而是你自己显式地
写出来的缺省构造函数。

class base{ 
base(){ 
System.out.println("base constructor"); 
} 
base(int i){ 
System.out.println("base constructor int i"); 
} 
} 
class derived extends base{ 
derived(){ 
System.out.println("derived constructor"); 
} 
derived(int i){ 
System.out.println("derived constructor int i"); 
} 
public static void main(String[] args){ 
derived d=new derived(); 
derived t=new derived(9); 
} 
} 

D:\java\thinking\think6>java derived 
base constructor 
derived constructor 
base constructor 
derived constructor int i 

如果将base 类的构造函数注释掉，则出错。

class base{ 
// base(){ 
// System.out.println("base constructor"); 
// } 
base(int i){ 
System.out.println("base constructor int i"); 
} 
} 
class derived extends base{ 
derived(){ 
System.out.println("derived constructor"); 
} 
derived(int i){ 
System.out.println("derived constructor int i"); 
} 
public static void main(String[] args){ 
derived d=new derived(); 
derived t=new derived(9); 
} 
} 


D:\java\thinking\think6>javac derived.java 
derived.java:10: cannot resolve symbol 
symbol : constructor base () 
location: class base 
derived(){ 
^ 
derived.java:13: cannot resolve symbol 
symbol : constructor base () 
location: class base 
derived(int i){ 
2 errors 

说明子类中的构造函数找不到显式写出的父类中的缺省
构造函数，所以出错。

那么如果你不想子类的构造函数调用你显式写出的父类中的缺省
构造函数怎么办呢？
如下例：

class base{ 
// base(){ 
// System.out.println("base constructor"); 
// } 
base(int i){ 
System.out.println("base constructor int i"); 
} 
} 
class derived extends base{ 
derived(){ 
super(8); 
System.out.println("derived constructor"); 
} 
derived(int i){ 
super(i); 
System.out.println("derived constructor int i"); 
} 
public static void main(String[] args){ 
derived d=new derived(); 
derived t=new derived(9); 
} 
} 


D:\java\thinking\think6>java derived 
base constructor int i 
derived constructor 
base constructor int i 
derived constructor int i 

super(i)表示父类的构造函数base(i)请大家注意
一个是super(i)一个是super(8)。
大家想想是为什么？？

结论：子类如果有多个构造函数的时候，父类要么没有构造函数，
让编译器自动产生，那么在执行子类构造函数之前先执行编
译器自动产生的父类的缺省构造函数；要么至少要有一个显
式的缺省构造函数可以让子类的构造函数调用。