Java 类和对象的初始化过程及初始化顺序

静态的属于全局静态区，这个部分独立存在，不管是成员还是块，都是静态的，大家地位相等，先到先得。
　　然后是成员初始化，这个部分在类的构造函数前初始化，因为编译器(或者设计者)可能认为构造函数调用了这个成员变量，所以在其前初始化了。或者说是成员自己有自己的能力来初始化自己，不用构造函数来管，这部分属于能力比较强的，虽然没有静态的地位高，但是，还是能自给自足的一部分团体。
　　最后才构造函数，这个时候就开始动工来建立这个类的实例了。这个步骤相当于建大楼，终于开始建立了，前面的准备工作已经准备完了，下面就开始对那些没有自理能力的成员进行初始化等。
　　对于继承的时候，先父类，后子类。同样理解，静态的地位还是依旧高，高于一切。然后再是有自理能力的成员变量，最后才构造函数来处理小兵小将。
　　注意：构造函数是先与“成员变量初始化”，也就是调用构造函数时会先调用父类(super())的构造函数，接着顶层的构造函数会先执行其成员变量的初始化，然后构造函数里其余的代码被执行，一层一层向下执行。

　java初始化顺序

　　1 无继承情况下的Java初始化顺序：

package com.yx.test;

public class NoExtendDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
         Test test = new Test();
    }

}


class Test {

    static Sample sam = new Sample("静态成员sam初始化");
    Sample sam1 = new Sample("sam1成员初始化");

    static {
        System.out.println("static块执行");
        if (sam == null)
            System.out.println("sam is null");
        sam = new Sample("静态块内初始化sam成员变量");
    }

    Test() {
        System.out.println("Test默认构造函数被调用");
    }
}

class Sample {

    Sample(String s){

        System.out.println(s);
    }

    Sample(){
        System.out.println("Sample默认构造函数被调用");
    }
}

输出结果为：
　
静态成员sam初始化 —–静态成员初始化
　　 static块执行 —–静态块被执行
　　 静态块内初始化sam成员变量 —-静态块执行
　　 sam1成员初始化 —–普通成员初始化
　　 Test默认构造函数被调用 —–构造函数执行

　　由此可以得出结论：
　　a 静态成员变量首先初始化(注意，Static可以看做一个静态成员，其执行顺序和其在类中申明的顺序有关)
　　b 普通成员初始化
　　c 执行构造函数。
　　对于静态成员(static块可以看成普通的一个静态成员，其并不一定在类初始化时首先执行)和普通成员， 其初始化顺序只与其在类定义中的顺序有关，和其他因素无关。

例如下面的例子：

package com.yx.test;

public class NoExtendDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
         Test test = new Test();
    }

}


//class Test {
//
//  static Sample sam = new Sample("静态成员sam初始化");
//  Sample sam1 = new Sample("sam1成员初始化");
//
//  static {
//      System.out.println("static块执行");
//      if (sam == null)
//          System.out.println("sam is null");
//      sam = new Sample("静态块内初始化sam成员变量");
//  }
//
//  Test() {
//      System.out.println("Test默认构造函数被调用");
//  }
//}
//
class Sample {

    Sample(String s){

        System.out.println(s);
    }

    Sample(){
        System.out.println("Sample默认构造函数被调用");
    }
}


class Test {
    static {
        System.out.println("static 块 1 执行");
    }
    static Sample staticSam1 = new Sample("静态成员staticSam1初始化");
    Sample sam1 = new Sample("sam1成员初始化");
    static Sample staticSam2 = new Sample("静态成员staticSam2初始化");
    static {
        System.out.println("static 块 2 执行");
    }

    Test() {
        System.out.println("Test默认构造函数被调用");
    }

    Sample sam2 = new Sample("sam2成员初始化");
}

则结果为：
　 static 块 1 执行
　　静态成员staticSam1初始化
　　静态成员staticSam2初始化
　　static 块 2 执行
　　——–静态成员
　　sam1成员初始化
　　sam2成员初始化
　　——–普通成员
　　Test默认构造函数被调用
　　——–构造函数

2 Java继承情况下的初始化顺序：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        TestSub test = new TestSub();
    }


public class Test {

    static {
        System.out.println("父类static 块 1 执行");
    }

    //当作普通成员变量
    {
        System.out.println("妈的靶子");
    }

    static Sample staticSam1 = new Sample("父类 静态成员staticSam1初始化");

    Sample sam1 = new Sample("父类 sam1成员初始化");

    static Sample staticSam2 = new Sample("父类 静态成员staticSam2初始化");

    static {
        System.out.println("父类 static 块 2 执行");
    }

    Test() {
        System.out.println("父类 Test默认构造函数被调用");
    }

    Sample sam2=new Sample("父类 sam2成员初始化");
}


class TestSub extends Test {
    static Sample staticSamSub = new Sample("子类 静态成员staticSamSub初始化");

    TestSub() {
        System.out.println("子类 TestSub 默认构造函数被调用");
    }

    Sample sam1 = new Sample("子类 sam1成员初始化");
    static Sample staticSamSub1 = new Sample("子类 静态成员staticSamSub1初始化");
    static {
        System.out.println("子类 static 块 执行");
    }
    Sample sam2 = new Sample("子类 sam2成员初始化");
}

　执行结果：
　　父类 static 块 1 执行
　　父类 静态成员staticSam1初始化
　　父类 静态成员staticSam2初始化
　　父类 static 块 2 执行
　　——–父类静态成员初始化
　　子类 静态成员staticSamSub初始化
　　子类 静态成员staticSamSub1初始化
　　子类 static 块 执行
　　——-子类静态成员初始化
　　妈的靶子
　　父类 sam1成员初始化
　　父类 sam2成员初始化
　　父类 Test默认构造函数被调用
　　——-父类普通成员初始化和构造函数执行
　　子类 sam1成员初始化
　　子类 sam2成员初始化
　　子类 TestSub 默认构造函数被调用
　　——-父类普通成员初始化和构造函数执行

由此得出Java初始化顺序结论：
　　1 继承体系的所有静态成员初始化(先父类，后子类)
　　2 父类初始化完成(普通成员的初始化-->构造函数的调用)
　　3 子类初始化(普通成员-->构造函数)