Java子父类中的构造函数实例化过程

其实我们发现子类继承父类操作很简单，如果要是去深入的研究下会发现，实例化过程并非是我们看到的那样，我们就以代码举例来说明；

---

问大家，以下代码执行会输出什么呢？

package com.oop;

/**
 * 定义动物对象
 * @author Liudeli
 *
 */
class Animal {

    public Animal() {
        System.out.println("Animal()--构造函数");
    }

}

/**
 * 定义狗对象
 * @author Liudeli
 *
 */
class Dog extends Animal{

}

/**
 * 子父类中的构造函数实例化过程
 * @author Liudeli
 *
 */
public class Demo1 {

    public static void main(String[] args) {

        Dog d = new Dog();

    }

}

没有去深究这个问题，大部分会回答，不输出任何，因为Dog类没有任何构造方法，如果这样想的其实就错了，它一定会输出父类无参构造方法的内容：

这是为什么呢？

答：其实只要我们随便创建一个类，就会有隐式的代码重点内容执行

会在子类的构造方法中执行 super(); 调用

/**
 * 定义狗对象
 * @author Liudeli
 *
 */
class Dog extends Animal{

    // 其实只要我们随便创建一个类，就会有隐式的代码执行，只是我们看不到而已
    Dog() {
        super();
        return;
    }

}

---

---

子类有一个有参构造方法，new 子类（true），调用子类的有参构造方法，父类的无参构造方法一定会执行，因为在子类的任何构造方法中，都会默认调用 super();

package com.oop;

/**
 * 定义动物对象
 * @author Liudeli
 *
 */
class Animal2 {

    public Animal2() {
        System.out.println("Animal()--构造函数");
    }

    public Animal2(boolean is) {
        System.out.println("Animal2(boolean is)--构造函数 is:" + is);
    }

}

/**
 * 定义狗对象
 * @author Liudeli
 *
 */
class Dog2 extends Animal{

    public Dog2() {

    }

    public Dog2(boolean is) {
        System.out.println("Dog2(boolean is)--构造函数 is:" + is);
    }

}

/**
 * 子父类中的构造函数实例化过程
 * @author Liudeli
 *
 */
public class Demo2 {

    public static void main(String[] args) {

        // 我调用的是，子类的有参构造方法，父类的无参构造方法会执行
        // 因为在子类的任何构造方法中，都会执行super();
        Dog2 dog = new Dog2(true);

    }

}

运行结果：

---

---

我们看不到的细节：

package com.oop;

/**
 * 定义动物对象
 * @author Liudeli
 *
 */
class Animal3 {

    public Animal3() {
        System.out.println("Animal()--构造函数");
    }

    public Animal3(boolean is) {
        System.out.println("Animal(boolean is)--构造函数 is:" + is);
    }

}

/**
 * 定义狗对象
 * @author Liudeli
 *
 */
class Dog3 extends Animal{

    public Dog3() {
        // super(); 默认就有，只是我们看不到而已，super()它在子类任何构造函数中的第一行
        super(false);  // 这样写报错，为什么会报错因为在子类的任何构造函数中都会执行 super()
                       // 你如果写了 super(参数); 就是不认它调用父类的super(), 所以它会报错
    }

    public Dog3(boolean is) {
        // super(); 默认就有，只是我们看不到而已，super()它在子类任何构造函数中的第一行
        super(false);  // 这样写报错，为什么会报错因为在子类的任何构造函数中都会执行 super()
                       // 你如果写了 super(参数); 就是不认它调用父类的super(), 所以它会报错
        System.out.println("Dog(boolean is)--构造函数 is:" + is);
    }

}

/**
 * 子父类中的构造函数实例化过程
 * @author Liudeli
 *
 */
public class Demo3 {

    /*
     *  Demo3 的实例化必须执行以下代码，只是隐式的看不到而已
     */
    // 主要 修饰符 public 是由于类开始定义的是public，所以它才是public，修饰符根据类的定义变化而变化
    public Demo3() {
        super();
        return;
    }

    public static void main(String[] args) {

        Dog3 dog = new Dog3(true);

    }

}

---

在这里有一个思考点，创建一个类不继承任何类，默认无参构造函数必须执行 super(); ,那super调用了那个父类的无参构造函数？

答：最终超类 Object。

所以我们这样写，没有任何问题，extends Object

package com.oop;

// 系统默认或直接间接的让Object成为了父类，extends Object，只是我们看不到而已
public class Demo4 extends Object {  

    /*
     *  Demo3 的实例化必须执行以下代码，只是隐式的看不到而已
     */
    // 主要 修饰符 public 是由于类开始定义的是public，所以它才是public，修饰符根据类的定义变化而变化
    public Demo4() {
        super();
        return;
    }

    public static void main(String[] args) {
        System.out.println("Demo4()...");
    }

}

运行结果：

---

父类写了一个有参构造方法，子类继承父类，子类必须要写一个和父类一样参数的构造方法，因为父类写了一个有参构造方法，父类的无参构造方法就没有了，子类的无参构造方法就调用不到父类的无参构造方法了，需要让子类的有参构造方法去super()调用；

public  class Observer {

    private String name;
    private Secretary secretary;

    public Observer(String name, Secretary secretary) {
        this.name = name;
        this.secretary = secretary;
    }

}

public class StockObserver extends Observer{

    // 子类必须要写一个和父类同参的构造方法
    public StockObserver(String name, Secretary secretary) {
        super(name, secretary);
        // TODO Auto-generated constructor stub
    }
}

---

谢谢大家的观看，更多精彩技术博客，会不断的更新，请大家访问，

刘德利CSDN博客， http://blog.csdn.net/u011967006