摘要：想來(lái)想去先來(lái)一題比較好輸出結(jié)果分析類(lèi)初始化順序父類(lèi)靜態(tài)變量父類(lèi)靜態(tài)代碼塊子類(lèi)靜態(tài)代碼塊父類(lèi)非靜態(tài)變量父類(lèi)非靜態(tài)代碼塊父類(lèi)構(gòu)造函數(shù)子類(lèi)非靜態(tài)變量子類(lèi)非靜態(tài)代碼塊子類(lèi)構(gòu)造函數(shù)非靜態(tài)代碼塊輸出結(jié)果順序非靜態(tài)代碼塊被編譯器拷貝到了構(gòu)造塊內(nèi)所以稱(chēng)

[toc]

public class Foo {
    public static void main(String[] args) {
        Baz.testAsserts();
        Baz.testAsserts();
        // Will execute after Baz is initialized.
    }
}

class Bar {
    static {
        Baz.testAsserts();
        // Will execute before Baz is initialized!
    }
}


class Baz extends Bar {
    static int x = 1;

    static void testAsserts() {

        System.out.println("x is " + x);
        x=x+2;
    }

}

輸出結(jié)果

x is 0  
x is 1  
x is 3

分析

Invoking Baz.testAsserts() cause Baz to be initialized
default value int x=0;
Before Baz initialize , Bar must be initialized
Bar"s static initializer again invoking Baz.testAsserts()
so x is 0 , then x+2 , x=2
go on initializing Baz , init x = 1;
Invoking Baz.testAsserts() x = 1 , so x is 1;

父類(lèi)靜態(tài)變量  ——>父類(lèi)靜態(tài)代碼塊——>子類(lèi)靜態(tài)代碼塊——>父類(lèi)非靜態(tài)變量  ——>  
父類(lèi)非靜態(tài)代碼塊——>父類(lèi)構(gòu)造函數(shù)  ——>子類(lèi)非靜態(tài)變量——>子類(lèi)非靜態(tài)代碼塊——>  
子類(lèi)構(gòu)造函數(shù)

class A {

    int x ;

    //block num 1
    {
        x = 1;
        System.out.println("block num 1, x is " + x);
    }

    A() {
        x = 3;
        System.out.println("constructor block x is " + x);
    }

    //block num 2
    {
        x = 2;
        System.out.println("block num 2, x is " + x);
    }

}


public class Non_staticBlock {

    public static void main(String[] args) {

        String newLine = System.getProperty("line.separator");

        System.out.println("====first time instantiate ====" + newLine);
        new A();

        System.out.println(" 
====second time instantiate ====" + newLine);
        new A();
    }

}

輸出結(jié)果、順序

====first time instantiate ==== 
block num 1, x is 1   
block num 2, x is 2   
constructor x is 3   
====second time instantiate ==== 
block num 1, x is 1   
block num 2, x is 2   
constructor x is 3

非靜態(tài)代碼塊被java編譯器拷貝到了構(gòu)造塊內(nèi),所以稱(chēng)為"constructor block"也是可以的,所以每次 new 構(gòu)造函數(shù)也都執(zhí)行

.class 文件如下, 非靜態(tài)代碼塊被java編譯器拷貝到了構(gòu)造塊內(nèi).

class A {
    int x = 1;

    A() {
        System.out.println("block num 1, x is " + this.x);
        this.x = 2;
        System.out.println("block num 2, x is " + this.x);
        this.x = 3;
        System.out.println("constructor x is " + this.x);
    }
}

class AA {

    AA() {
        x = 3;
        System.out.println("constructor x is " + x);
    }

    static int x = 1;

    //block num 1
    static {
        System.out.println("static block num 1 , x is " + x);
    }

    //block num 2
    static {
        x = 2;
        System.out.println("static block num 2 , x is " + x);
    }

    static void print() {
        System.out.println("static method");
    }
}


public class StaticBlock {
        static {
        System.out.println("==== first ====");
    }

    public static void main(String[] args) {
        String newLine = System.getProperty("line.separator");
        System.out.println("====AA class init ====" + newLine);
        // class init
        AA.print();
        
        System.out.println(" 
====fisrt time instantiate AA====" + newLine);
        
        new AA();
        System.out.println(" 
====sencond time instantiate AA====" + newLine);
        new AA();
    }
}

輸出結(jié)果、順序

==== first ====   
====AA class init ====
static block num 1 , x is 1  
static block num 2 , x is 2  
static method  
==== first time instantiate AA ====  
constructor x is 3  
==== second time instantiate AA ====  
constructor x is 3

由于JVM在加載類(lèi)時(shí)會(huì)執(zhí)行靜態(tài)代碼塊,且只會(huì)執(zhí)行一次. 本例靜態(tài)引用AA.print(); 觸發(fā)類(lèi)初始化

靜態(tài)代碼塊先于主方法執(zhí)行,本例優(yōu)先打印first

更多內(nèi)容搜索jvm類(lèi)加載

.class 文件如下

class AA {
    static int x = 1;

    AA() {
        x = 3;
        System.out.println("constructor x is " + x);
    }

    static void print() {
        System.out.println("static method");
    }

    static {
        System.out.println("static block num 1 , x is " + x);
        x = 2;
        System.out.println("static block num 2 , x is " + x);
    }
}

class AAA {
    int x;

    //block num 1
    {
        x = 1;
        System.out.println("non-static block num 1 x is " + x);
    }

    AAA() {
        x = 3;
        System.out.println("constructor x is " + x);

    }

    //block num 2
    {
        x = 2;
        System.out.println("non-static block num 2 x is " + x);
    }


    // The static block only gets called once,when the class itself is initialized,
    // no matter how many objects of that type you create
    static {
        System.out.println("static block");
    }


    //Gets called every time an instance of the  class is constructed.
    //the non-static block is actually copied by the Java compiler into every constructor the class has (source).
    //So it is still the constructor"s job to initialize fields.
    //to understand "actually " , find the result in the .class file of A.class
    {
        System.out.println("non-static block");
    }
}


public class BlockSample {

    public static void main(String[] args) {

        String newLine = System.getProperty("line.separator");

        System.out.println("====first time instantiate AAA ====" + newLine);
        new AAA();

        System.out.println(" 
====second time instantiate AAA ====" + newLine);
        new AAA();

    }
}

輸出結(jié)果、順序

====first time instantiate AAA ====
static block  
non-static block num 1 x is 1  
non-static block num 2 x is 2  
non-static block  
constructor x is 3  
====second time instantiate AAA ====  
non-static block num 1 x is 1  
non-static block num 2 x is 2  
non-static block  
constructor x is 3

.class 文件

class AAA {
    int x = 1;

    AAA() {
        System.out.println("non-static block num 1 x is " + this.x);
        this.x = 2;
        System.out.println("non-static block num 2 x is " + this.x);
        System.out.println("non-static block");
        this.x = 3;
        System.out.println("constructor x is " + this.x);
    }

    static {
        System.out.println("static block");
    }
}