本文重点关注静态块、非静态块、构造函数的加载顺序
直接上代码:
package test.staticblock;
public class A {
/*父类构造方法*/
public A(){
System.out.println("A constructor");
}
/*父类静态块*/
static
{
System.out.println("A static Block");
}
/*父类非静态块*/
{
System.out.println("A non-static Block");
}
/*父类静态方法*/
public static void printStaticMethod(){
System.out.println("A print Static Method");
}
/*父类普通方法*/
public void printNormalMethod(){
System.out.println("A print Normal Method");
}
}
class B extends A{
/*子类1构造方法*/
public B(){
System.out.println("B constructor");
}
/*子类1静态块*/
static{
System.out.println("B static Block");
}
/*子类1非静态块*/
{
System.out.println("B non-static Block");
}
/*子类1静态方法*/
public static void printStaticMethod(){
System.out.println("B print Static Method");
}
/*子类1普通方法*/
public void printNormalMethod(){
System.out.println("B print Normal Method");
}
}
class C extends A{
/*子类2构造方法*/
public C(){
System.out.println("C constructor");
}
/*子类2静态块*/
static{
System.out.println("C static Block");
}
/*子类2非静态块*/
{
System.out.println("C non-static Block");
}
/*子类2静态方法*/
public static void printStaticMethod(){
System.out.println("C print Static Method");
}
/*子类2没有override父类的普通方法*/
}
package test.staticblock;
public class Test {
public static void main(String[] args){
A a1 = new B();
A a2 = new C();
a1.printStaticMethod();
a1.printNormalMethod();
a2.printStaticMethod();
a2.printNormalMethod();
}
}
运行结果:
A static Block
B static Block
A non-static Block
A constructor
B non-static Block
B constructor
C static Block
A non-static Block
A constructor
C non-static Block
C constructor
A print Static Method
B print Normal Method
A print Static Method
A print Normal Method
根据结果分析:
顺序应该是这样的:父类Static->子类static->父类缺省{}->父类构造函数->子类缺省{}->子类构造函数
A static Block | 父类静态块 |
B static Block | 子类1静态块 |
A non-static Block | 父类非静态块,缺省块 |
A constructor | 父类构造函数 |
B non-static Block | 子类1非静态块,缺省块 |
B constructor | 子类1构造函数 |
C static Block | 子类2静态块,由此可以看出static块仅在类加载时执行且仅执行一遍,因为A的静态块已经执行过了,这里不会再执行。 |
A non-static Block | 父类非静态块,缺省块 |
A constructor | 父类构造函数 |
C non-static Block | 子类2非静态块,缺省块 |
C constructor | 子类2构造函数 |
B print Static Method B print Vitural Method C print Static Method A print Vitural Method |
|
分析:当执行new B()和new C()时,它首先去看父类里面有没有静态代码块,如果有,它先去执行父类里面静态代码块里面的内容,当父类的静态代码块里面的内容执行完毕之后,接着去执行子类(自己这个类)里面的静态代码块,当子类的静态代码块执行完毕之后,它接着又去看父类有没有非静态代码块,如果有就执行父类的非静态代码块,父类的非静态代码块执行完毕,接着执行父类的构造方法;父类的构造方法执行完毕之后,它接着去看子类有没有非静态代码块,如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法,这个就是一个对象的初始化顺序。
总结:对象的初始化顺序:首先执行父类静态的内容,父类静态的内容执行完毕后,接着去执行子类的静态的内容,当子类的静态内容执行完毕之后,再去看父类有没有非静态代码块,如果有就执行父类的非静态代码块,父类的非静态代码块执行完毕,接着执行父类的构造方法;父类的构造方法执行完毕之后,它接着去看子类有没有非静态代码块,如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法。总之一句话,静态代码块内容先执行,接着执行父类非静态代码块和构造方法,然后执行子类非静态代码块和构造方法。
注意:子类的构造方法,不管这个构造方法带不带参数,默认的它都会先去寻找父类的不带参数的构造方法。如果父类没有不带参数的构造方法,那么子类必须用supper关键子来调用父类带参数的构造方法,否则编译不能通过。
重要一点:
static 块仅在类加载时,并非实例化时,被执行一遍,且在整个过程中只可能被执行一遍,这也就是在实例化C时
A a2 = new C();
但非静态块在实例化对象时总会被执行。
静态块一般用于初始化类中的静态成员;而非静态块一般用于初始化类中的非静态成员;
另外,非静态块是在创建对象时自动执行的代码。