11.2.2 默认构造方法
默认构造方法是没有参数的构造方法,可分为两种:(1)隐含的默认构造方法;(2)程序显式定义的默认构造方法。
Java语言中,每个类至少有一个构造方法。为了保证这一点,如果用户定义的类中没有提供任何构造方法,那么Java语言将自动提供一个隐含的默认构造方法。该构造方法没有参数,用public 修饰,而且方法体为空,格式如下:
public ClassName(){} //隐含的默认构造方法
在程序中也可以显式地定义默认构造方法,它可以是任意的访问级别。例如:
protected Employee() { //程序显式定义的默认构造方法
this("无名氏");
}
如果类中显式定义了一个或多个构造方法,并且所有的构造方法都带参数,那么这个类就失去了默认构造方法。在以下程序中,Sample1类有一个隐含的默认构造方法,Sample2类没有默认构造方法,Sample3类有一个显式定义的默认构造方法。
public class Sample1{}
public class Sample2{
public Sample2(int a){System.out.println("My Constructor");}
}
public class Sample3{
public Sample3(){System.out.println("My Default Constructor");}
}
可以调用Sample1类的默认构造方法来创建Sample1对象。
Sample1 s=new Sample1(); //合法
Sample2类没有默认构造方法,因此以下语句会导致编译错误。
Sample2 s=new Sample2(); //编译出错
Sample3类显式定义了默认构造方法,因此以下语句是合法的。
Sample3 s=new Sample3();

11.2.3 子类调用父类的构造方法

父类的构造方法不能被子类继承。以下语句中MyException类继承了java.lang.Exception类。
public class MyException extends Exception{} // MyException类只有一个隐含的默认构造方法
尽管在Exception类中定义了如下形式的构造方法:
public Exception(String msg)
MyException类不会继承以上Exception类的构造方法,因此以下代码是不合法的。
//编译出错,MyException类不存在这样的构造方法
Exception e=new MyException("Something is error");
在子类的构造方法中,可以通过super语句调用父类的构造方法。例如:
public class MyException extends Exception{
public MyException(){
//调用Exception父类的Exception(String msg)构造方法
super("Something is error");
}
public MyException(String msg){
//调用Exception父类的Exception(String msg)构造方法
super(msg);
}
}
super语句来调用父类的构造方法时,必须遵守以下语法规则。
l 在子类的构造方法中,不能直接通过父类方法名调用父类的构造方法,而是要使用super语句,以下代码是非法的:
public MyException(String msg){
Exception(msg); //编译错误
}
l 假如在子类的构造方法中有super语句,它必须作为构造方法的第一条语句,以下代码是非法的:
public MyException(){
String msg= "Something wrong";
super(msg); //编译错误,super语句必须作为构造方法的第一条语句
}
在创建子类的对象时,Java虚拟机首先执行父类的构造方法,然后再执行子类的构造方法。在多级继承的情况下,将从继承树的最上层的父类开始,依次执行各个类的构造方法,这可以保证子类对象从所有直接或间接父类中继承的实例变量都被正确地初始化。例如以下父类Base和子类Sub分别有一个实例变量ab,当构造Sub实例时,这两个实例变量都会被初始化。
public class Base{
private int a;
public Base(int a){ this.a=a;}
public int getA(){return a;}
}
public class Sub extends Base{
private int b;
public Base(int a,int b){super(a); this.b=b;}
public int getB(){return b;}
public static void main(String args[]){
Sub sub=new Sub(1,2);
System.out.println("a="+sub.getA()+" b="+sub.getB()); //打印a=1 b=2
}
}
在例程11-3Son.java)中,Son类继承Father类,Father类继承Grandpa类。这3个类都显式定义了默认的构造方法,此外还定义了一个带参数的构造方法。
例程11-3 Son.java
class Grandpa{
protected Grandpa(){
System.out.println("default Grandpa");
}
public Grandpa(String name){
System.out.println(name);
}
}
class Father extends Grandpa{
protected Father(){
System.out.println("default Father");
}
public Father(String grandpaName,String fatherName){
super(grandpaName);
System.out.println(fatherName);
}
}
public class Son extends Father{
public Son(){
System.out.println("default Son");
}
public Son(String grandpaName,String fatherName,String sonName){
super(grandpaName,fatherName);
System.out.println(sonName);
}
public static void main(String args[]){
Son s1= new Son("My Grandpa", "My Father", "My Son"); //
Son s2=new Son(); //
}
}
执行以上main()方法的第条语句,打印结果如下:
My Grandpa
My Father
My Son
此时构造方法的执行顺序如图11-1所示。
如果子类的构造方法没有用super语句显式调用父类的构造方法,那么通过这个构造方法创建子类对象时,Java虚拟机会自动先调用父类的默认构造方法。执行以上Son类的main()方法的第条语句,打印结果如下:
default Grandpa
default Father
default Son
此时构造方法的执行顺序如图11-2所示。

11-1 调用Son类的带参数的构造方法时


11-2 调用Son类的默认构造方法时
所有构造方法的执行顺序 所有构造方法的执行顺序
当子类的构造方法没有用super语句显式调用父类的构造方法,而父类又没有提供默认构造方法时,将会出现编译错误。例如把例程11-3做适当修改,删除Grandpa类中显式定义的默认构造方法。
// protected Grandpa(){
// System.out.println("default GrandPa");
// }
这样,Grandpa类就失去了默认构造方法,此时编译Father类的默认构造方法,因为找不到Grandpa类的默认构造方法而编译出错。如果把Grandpa类的默认构造方法的protected访问级别改为private访问级别,也会导致编译错误,因为Father类的默认构造方法无法访问Grandpa类的私有默认构造方法。
在以下例子中,子类Sub的默认构造方法没有通过super语句调用父类的构造方法,而是通过this语句调用了自身的另一个构造方法Sub(int i),在Sub(int i)中通过super语句调用了父类BaseBase(int i)构造方法。这样,无论通过Sub类的哪个构造方法来创建Sub实例,都会先调用父类BaseBase(int i)构造方法。
class Base{
Base(int i){System.out.println("call Base(int i)");}
}
public class Sub extends Base{
Sub(){this(0); System.out.println("call Sub()");}
Sub(int i){super(i); System.out.println("call Sub(int i)");}
public static void main(String args[]){
Sub sub=new Sub();
}
}
执行以上Sub类的main()方法的new Sub()语句,打印结果如下:
call Base(int i)
call Sub(int i)
call Sub()

11-3 调用Sub类的默认构造方法时所有构造方法的执行顺序
此时构造方法的执行顺序如图11-3所示。
在下面的例子中,Base类中没有定义任何构造方法,它实际上有一个隐含的默认构造方法:
Base(){}
Sub类的Sub(int i)构造方法没有用super语句显式调用父类的构造方法,因此当创建Sub实例时,会先调用Base父类的隐含默认构造方法。
class Base{} //具有隐含默认构造方法
public class Sub extends Base{
Sub(int i){System.out.println(i);}
public static void main(String args[]){
System.out.println(new Sub(1)); //打印1
}
}