JAVA的继承关系中，构造方法调用问题

转载于：JAVA的继承关系中，构造方法调用问题

考虑下下面代码输出结果

public class test3 {
    public static void main(String[] args) {
        new Child("mike");
    }
}
class People {
    String name;
    public People() {
        System.out.print(1);
    }
    public People(String name) {
        System.out.print(2);
        this.name = name;
    }
}

class Child extends People {
    People father;
    public Child(String name) {
        System.out.print(3);
        this.name = name;
        father = new People(name + ":F");
    }
    public Child() {
        System.out.print(4);
    }
}

答案在最后

下面是一个延伸题

public class Dervied extends Base {
    private String name = "dervied";
    public Dervied() {
        tellName();
        printName();
    }
    public void tellName() {
        System.out.println("Dervied tell name: " + name);
    }
    public void printName() {
        System.out.println("Dervied print name: " + name);
    }
    public static void main(String[] args){
        new Dervied();    
    }
}

class Base {
    private String name = "base";
    public Base() {
        tellName();
        printName();
    }
    public void tellName() {
        System.out.println("Base tell name: " + name);
    }
    public void printName() {
        System.out.println("Base print name: " + name);
    }
}

第一题答案：  132

解析：考察的又是父类与子类的构造函数调用次序。在Java中，子类的构造过程中必须调用其父类的构造函数，是因为有继承关系存在时，子类要把父类的内容继承下来。但如果父类有多个构造函数时，该如何选择调用呢？

第一个规则：子类的构造过程中，必须调用其父类的构造方法。一个类，如果我们不写构造方法，那么编译器会帮我们加上一个默认的构造方法（就是没有参数的构造方法），但是如果你自己写了构造方法，那么编译器就不会给你添加了，所以有时候当你new一个子类对象的时候，肯定调用了子类的构造方法，但是如果在子类构造方法中我们并没有显示的调用基类的构造方法，如：super();  这样就会调用父类没有参数的构造方法。    

第二个规则：如果子类的构造方法中既没有显示的调用基类构造方法，而基类中又没有无参的构造方法，则编译出错，所以，通常我们需要显示的：super(参数列表)，来调用父类有参数的构造函数，此时无参的构造函数就不会被调用。

总之，一句话：子类没有显示调用父类构造函数，不管子类构造函数是否带参数都默认调用父类无参的构造函数，若父类没有则编译出错。

第二题：

Dervied tell name: null
Dervied print name: null
Dervied tell name: dervied
Dervied print name: dervied

解析：

在第一题的基础上，

子类的构造过程中必须调用其父类的构造函数，因为有继承关系存在时，先父后子；

其次：子类可以访问父类的非私有成员变量和非私有方法，但是父类不可以访问子类的一切

第二部分（个人验证过的）

子父类中的构造函数的特点：　　

1.在子类构造对象时，发现，访问子类构造函数时，父类构造函数也运行了。
   原因是：在子类的构造函数中第一行有一语句。 super();

   类似于this();   this();调用的是本类的构造函数

2.supre语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。如果不放在子类构造函数的第一行，         super();就会报错。

3.同时子类构造函数中如果使用this调用了本类构造函数时，那么super就没有了，因为super和this都只能定义第一行,所以只能有一个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。

4.子类构造函数默认调用的是父类中的空参数构造函数，如果需要调用父类中带参数的构造函数，可以在子类构造函数中定义。如：super(6);

public class JichengTest {
    private String value1;
    
    private String value2;
    
    public String value3;
    
   public JichengTest(){
    	System.out.println("I am just parent");
    }
}

public class ChildTest extends JichengTest {
	
	public ChildTest(){
		//super();
		System.out.println("I am just ChildTest");			
	}
	
	public ChildTest(int num){
		this();
		System.out.println("I am just ChildTest and have a num");
	}

public static void main(String[] args) {
	
		ChildTest test = new ChildTest();
		System.out.println(" -----");
		ChildTest test2 = new ChildTest(2);
		System.out.println("main end");
	}
}	

结果为：

I am just parent

I am just ChildTest

 -----

I am just parent
I am just ChildTest
I am just ChildTest and have a num

main end

5.java：当父类无无参构造函数并且有其他构造函数时，子类不能调用默认构造函数

class Parent{
	public Parent(int b) {
	}
	
	public void getA()
	{
		System.out.println("getA");
	}
}
class Child extends Parent{
	
	public Child() {
		super();//编译不通过
	}
	public void getA() {
		System.out.println("sadf");
	}
}
public class Test{
	public static void main(String[] args) {
		Parent aParent=new Child();
	
	}
}

 结合：子类没有显示调用父类构造函数，不管子类构造函数是否带参数都默认调用父类无参的构造函数，若父类没有则编译出错。以及当父类无无参构造函数并且有其他构造函数时，子类不能调用默认构造函数。

出现了下面的问题：

  java中只要调用子类的构造函数就要调用父类无参数的构造函数吗？若父类中不存在无参数构造函数会出错吗?

答：Java中只要调用子类的构造函数就一定会调用父类的构造函数，这是毋庸置疑的！有时我们并没有在父类中写有参和无参的构造方法，但是这样我们在定义子类对象时调用子类构造函数时，其实也调用父类的构造函数，这是系统自动为我们添加的“public Pen(){}”。但是如果我们在父类中已经自己定义了有参的构造方法，却没有定义无参的构造方法，那么此时系统是不会为我们自动添加无参的构造方法的，此时程序结果就会提醒你父类没有无参的构造方法，程序就会报错。

class Pen {
     public Pen(){}
     public Pen(String newColor, double newLength, double newPrice){
       .............................;
       .............................;
     }
}
class Pencile extends Pen{
    public  static int count=0;
     public Pencile(){
       count++;
     }
     public int GetCount(){
      return count;
     }
public class Test {
     public static void main(String[] args){
      Pencile A=new Pencile(); 
      Pencile B=new Pencile();
      System.out.println( "共创建了"+A.GetCount()+"个实例！" );
  }
}

      这段代码的结果应该是：共创建了2个实例！，这个结果是不难想象的，但是如果这段代码我们把“public Pen(){}”这段无参的构造函数注释掉的话，那么这个程序就会出现问题了。但是如果我们不但注释掉“public Pen(){}”,同样的我们也注释掉“ public Pen(String newColor, double newLength, double newPrice){}”这样的有参数的构造函数，那么这个程序又能执行了，而且输出同样的结果。正好说明了上面的结论。

   参考链接有：https://blog.csdn.net/xiayizhanqihang/article/details/55808059    

    https://www.cnblogs.com/weihao950903/p/5310845.html