Java 靜態塊 、構造塊、構造函數執行順序

請先參照這兩個帖子：
http://blog.csdn.net/kingzone_2008/article/details/45015301
http://bbs.csdn.net/topics/391001417%20%22%22
靜態塊：用static申明，JVM加載類時執行，僅執行一次
構造塊：類中直接用{}定義，每一次創建對象時執行
執行順序優先級：靜態塊>main()>構造塊>構造方法
靜態塊和靜態屬性優先執行，誰在前就先執行誰
注意：
1、每調用一次構造方法，則執行一次構造塊
2、靜態塊只在類加載的時候加載一次
3、有多個靜態變量或塊時，按聲明順序加載

public class Practice {  
    public static void main(String[] args) {  
        new Father();  
        new Son();  
    }  
}  
class Father {  
    protected int n = 5;  
    protected static int m = 5;
    public static Father p = new Father();
    public static Father p1 = new Father();

    {//構造塊  
        n = n * 2;  
        m = m * 2;  
        System.out.print("父類**構造塊**調用；");
        System.out.print("n="+n);  
        System.out.println("  m="+m);  
    }  

    static {//實例化多個對象時，靜態塊只執行一次，即在第一個實例化對象時執行
        m = m * 2;  
        System.out.println("父類%%靜態塊%%調用； m="+m);  
    }  


    public Father() {  //父類構造函數
        this.n = n * 10;  
        m = m + 10;  
        System.out.print("父類$$構造函數$$；   n="+n);  
        System.out.println("    m="+m);  
    }  
}  

class Son extends Father {  
    private int sn=3;  
    private static int sm=3;  
    static {  
        m = m + 2;  
        sm=sm+2;  
        System.out.println("【 子類 】@@ 靜態塊 @@調用；    m="+m);  
    }  
    {  
        n = n + 2;  
        sn=sn+2;  
        m = m + 2;  
        System.out.println("【 子類 】^^ 構造塊 ^^調用；");  
        System.out.println("n="+n);  
        System.out.println("sn="+sn);  
        System.out.println("m="+m);  
    }  

    public Son() {  
        this.n = n + 10;  
        sn=sn+10;  
        m = m + 10;  
        System.out.println("【 子 類 】[[ 構造函數 ]]；\nn="+n);  
        System.out.println("m="+m);  
    }  
}   

結果：（一）

父類**構造塊**調用；n=10  m=10
父類$$構造函數$$；   n=100    m=20
父類**構造塊**調用；n=10  m=40
父類$$構造函數$$；   n=100    m=50
父類%%靜態塊%%調用； m=100
父類**構造塊**調用；n=10  m=200
父類$$構造函數$$；   n=100    m=210
【 子類 】@@ 靜態塊 @@調用；    m=212
父類**構造塊**調用；n=10  m=424
父類$$構造函數$$；   n=100    m=434
【 子類 】^^ 構造塊 ^^調用；
n=102
sn=5
m=436
【 子 類 】[[ 構造函數 ]]；
n=112
m=446

結果（二）：【將main()函數的new Son()註釋掉的運行結果】

**父類**構造塊**調用；n=10  m=10
父類$$構造函數$$；   n=100    m=20
父類**構造塊**調用；n=10  m=40
父類$$構造函數$$；   n=100    m=50
父類%%靜態塊%%調用； m=100
父類**構造塊**調用；n=10  m=200
父類$$構造函數$$；   n=100    m=210**

結果（三）：【將Father類中的兩個引用p、p1註釋掉的運行結果，結果二中的new Son();也註釋掉】

父類%%靜態塊%%調用； m=10
父類**構造塊**調用；n=10  m=20
父類$$構造函數$$；   n=100    m=30

結果（四）：【將Father類中的兩個引用p、p1註釋掉的運行結果，結果二中的new Son();不註釋掉】

父類%%靜態塊%%調用； m=10
父類**構造塊**調用；n=10  m=20
父類$$構造函數$$；   n=100    m=30
【 子類 】@@ 靜態塊 @@調用；    m=32
父類**構造塊**調用；n=10  m=64
父類$$構造函數$$；   n=100    m=74
【 子類 】^^ 構造塊 ^^調用；
n=102
sn=5
m=76
【 子 類 】[[ 構造函數 ]]；
n=112
m=86