java继承中的构造方法

继承中的构造方法

有以下几个结论：

（1）父类的无参构造函数存在时，父类的（无参）构造方法会被子类的（所有）构造方法（必须）在第一行默认（隐式）调用。

代码如下：

public class Test {
	public static void main(String[] args) {
		Son s = new Son();
		System.out.println("--------------");
		Son s1 = new Son(6);		
	}
}

class Father{
	//默认无参构造函数
	public Father(){
		System.out.println("Father的无参构造函数");
	}
//	public Father(int x){
//		System.out.println("Father的有参构造函数");
//	}
}

class Son extends Father{
	public Son(){
		//super();   //默认调用，此时写不写都行
		System.out.println("Son的无参构造函数");
	}
	public Son(int x){
		//super();  //默认调用，此时写不写都行
		System.out.println("Son的有参构造函数");
	}
}

打印结果：

Father的无参构造函数
Son的无参构造函数
--------------
Father的无参构造函数
Son的有参构造函数

（2）父类的无参构造函数存在，有参构造也存在时，父类的（有参）构造方法可以被子类的（所有）构造方法（必须）在第一行显示调用。

代码如下：

public class Test {
	public static void main(String[] args) {
		Son s = new Son();
		System.out.println("--------------");
		Son s1 = new Son(6);		
	}
}

class Father{
	//默认无参构造函数
	public Father(){
		System.out.println("Father的无参构造函数");
	}
	public Father(int x){
		System.out.println("Father的有参构造函数");
	}
}

class Son extends Father{
	public Son(){
		super(3);   //显示调用，必须写
		System.out.println("Son的无参构造函数");
	}
	public Son(int x){
		super(3);   //显示调用，必须写
		System.out.println("Son的有参构造函数");
	}
}

打印结果：

Father的有参构造函数
Son的无参构造函数
--------------
Father的有参构造函数
Son的有参构造函数

（3）父类的无参构造函数不存在时，父类的（无参）构造方法也会被子类的（所有）构造方法在第一行默认调用，但是会出错。

代码如下：

public class Test {
	public static void main(String[] args) {
		Son s = new Son();
		System.out.println("--------------");
		Son s1 = new Son(6);		
	}
}

class Father{
	
	// 未定义无参构造函数，只存在有参构造函数
	public Father(int x){
		System.out.println("Father的有参构造函数");
	}
}

class Son extends Father{
	public Son(){
		super();   //默认调用。因为父类无参不存在，此时调用会出错
		System.out.println("Son的无参构造函数");
	}
	public Son(int x){
		super();   //默认调用。因为父类无参不存在，此时调用会出错
		System.out.println("Son的有参构造函数");
	}
}

打印结果：无法编译

（4）父类的无参构造函数不存在，有参构造也存在时，父类的（有参）构造方法可以会被子类的（所有）构造方法在第一行显式调用。

代码如下：

public class Test {
	public static void main(String[] args) {
		Son s = new Son();
		System.out.println("--------------");
		Son s1 = new Son(6);		
	}
}

class Father{
	
	// 未定义无参构造函数，只存在有参构造函数
	public Father(int x){
		System.out.println("Father的有参构造函数");
	}
}

class Son extends Father{
	public Son(){
		super(3);   //显式调用，必须写
		System.out.println("Son的无参构造函数");
	}
	public Son(int x){
		super(3);   //显式调用，必须写
		System.out.println("Son的有参构造函数");
	}
}

打印结果：

Father的有参构造函数
Son的无参构造函数
--------------
Father的有参构造函数
Son的有参构造函数

结论：

（1）子类的构造方法默认访问父类的（无参）构造方法。

（2）父类的（无参或有参）构造方法可以被子类调用，前提是必须存在，且必须在子类的构造方法的第一行。

（3）子类的构造方法只能调用父类的一个构造方法（无参，或一个有参）。解释：子类的构造方法的第一行只能写一个父类的构造方法。

（4）为什么子类的构造方法必须调用父类的构造方法呢？解释：父类的构造方法可以给父类的成员变量赋值，赋值后的变量以便给子类继承，确保变量被正确初始化。