从一个例子看新建对象的初始化步骤

例子中,有子,父,祖父三级继承结构,它们每个类中都含有各自的私有成员对象,公共成员对象和静态成员对象以及静态和非静态代码块

例子如下

public class InitializationSequenceDemo {
    public static void main(String[] args) {
        Son c = new Son();
    }
}

/**
* 祖父类
*/
class Grandfather {
    {
        System.out.println("Code block1-->Grandfather");
    }
    static {
        System.out.println("Static Code block 1-->Grandfather");
    }
    private PrivateClass privateClass = new PrivateClass("Grandfather");
    public PublicClass publicClass = new PublicClass("Grandfather");
    static StaticClass staticClass = new StaticClass("Grandfather");
    {
        System.out.println("Code block2-->Grandfather");
    }
    static {
        System.out.println("Static Code block 2-->Grandfather");
    }
    public Grandfather() {
        System.out.println("Grandfather()");
    }
}

/**
* 父类
*/
class Father extends Grandfather {
    private PrivateClass privateClass = new PrivateClass("Father");
    public PublicClass publicClass = new PublicClass("Father");
    static StaticClass staticClass = new StaticClass("Father");
    static {
        System.out.println("Static Code block-->Father");
    }
    {
        System.out.println("Code block-->Father");
    }
    public Father() {
        System.out.println("Father()");
    }
}

/**
* 子类
*/
class Son extends Father {
    private PrivateClass privateClass = new PrivateClass("Son");
    public PublicClass publicClass = new PublicClass("Son");
    static StaticClass staticClass = new StaticClass("Son");
    static {
        System.out.println("Static Code block-->Son");
    }
    {
        System.out.println("Code block-->Son");
    }
    public Son() {
        System.out.println("Son()");
    }
}

class PrivateClass {
    public PrivateClass(String from) {
        System.out.println("PrivateClass("+from+")");
    }
}

class StaticClass extends  StaticClassFather{
    public StaticClass(String from) {
        super(from);
        System.out.println("StaticClass("+from+")");
    }
}

class StaticClassFather {
    public StaticClassFather(String from) {
        System.out.println("StaticClassFather("+from+")");
    }
}
class PublicClass{
    public PublicClass(String from) {
        System.out.println("PublicClass("+from+")");
    }
}
/*
运行结果如下
StaticClass(Grandfather)
Static Code block-->Grandfather
StaticClass(Father)
Static Code block-->Father
StaticClass(Son)
Static Code block-->Son
PrivateClass(Grandfather)
PublicClass(Grandfather)
Code block-->Grandfather
Grandfather()
PrivateClass(Father)
PublicClass(Father)
Code block-->Father
Father()
PrivateClass(Son)
PublicClass(Son)
Code block-->Son
Son()
*/

main方法中,我new了一个子类对象,调用该对象的构造方法,根据默认的super(),来到父类的空参构造;
同样的,父类空参构造里也有默认的super(),又来到了祖父类的空参构造

p.s. 所有有参构造方法都必须在第一行显式指明使用的父类构造方法即super(参数);而无参构造里面默认为super(),调用父类无参构造. -->根据 Think In Java第四版 130页

进入祖父类之后,在正式执行构造方法之前,需要将静态成员先初始化,将静态代码块执行

p.s. 构造方法都是隐式的static方法,当一个类static方法被第一次调用之前,所有静态成员变量和静态代码块要被初始化和执行; -->根据 Think In Java第四版 157页

我在静态成员对象上方和下方都加了代码块,可以看出,从上往下执行;
然后按照继承的顺序,从祖父类到父类到子类,将静态成员变量和静态代码块都加载完

见结果中的

/*
StaticClass(Grandfather)
Static Code block-->Grandfather
StaticClass(Father)
Static Code block-->Father
StaticClass(Son)
*/

然后,祖父类构造方法正式执行,先把该类每个非静态成员变量初始化,再执行构造方法;

使用同样的顺序初始化父类,最后是子类

目前只知其然,等研究了编译器原理再补充底层实现吧

转载于:https://www.cnblogs.com/XmCui/p/10905500.html