java“块”的研究

本文重点关注静态块、非静态块、构造函数的加载顺序

直接上代码：

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();

A的static块没有被执行的原因。

但非静态块在实例化对象时总会被执行。

静态块一般用于初始化类中的静态成员；而非静态块一般用于初始化类中的非静态成员；

另外，非静态块是在创建对象时自动执行的代码。

部分参考：

http://blog.sina.com.cn/s/blog_499b09000100d9rj.html