例子中,有子,父,祖父三级继承结构,它们每个类中都含有各自的私有成员对象,公共成员对象和静态成员对象以及静态和非静态代码块
例子如下
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)
*/
然后,祖父类构造方法正式执行,先把该类每个非静态成员变量初始化,再执行构造方法;
使用同样的顺序初始化父类,最后是子类