类、变量、块、构造器、继承初始化顺序,终极解答。

最近发现微信群里面有些群友在讨论类的初始化顺序,如类的静态变量、成员变量、静态代码块、非静态代码块、构造器,及继承父类时,它们的初始化顺序都是怎样的,下面我通过例子来说明这个情况,以免被人误导。

示例1:测试单类的初始化顺序

  1. publicclassClassInitOrderTest{
  2.    publicstaticString staticField ="static field";
  3.    static{
  4.        System.out.println(staticField);
  5.        System.out.println("static block");
  6.    }
  7.    privateString field ="member field";
  8.    {
  9.        System.out.println(field);
  10.        System.out.println("non-static block");
  11.    }
  12.    publicClassInitOrderTest(){
  13.        System.out.println("constructor");
  14.    }
  15.    publicstaticvoid main(String[] args){
  16.        newClassInitOrderTest();
  17.    }
  18. }
程序输出:
  1. static field
  2. static block
  3. member field
  4. non-static block
  5. constructor
可以得出以下结论:
静态变量 > 静态初始块 > 成员变量 > 非静态初始块 > 构造器

示例2:测试类继承的初始化顺序

  1. classParent{
  2.    privatestaticString parentStaticField ="parent static field";
  3.    static{
  4.        System.out.println(parentStaticField);
  5.        System.out.println("parent static block");
  6.    }
  7.    privateString parentField ="parent member field";
  8.    {
  9.        System.out.println(parentField);
  10.        System.out.println("parent non-static block");
  11.    }
  12.    publicParent(){
  13.        System.out.println("parent constructor");
  14.    }
  15. }
  16. publicclassChildextendsParent{
  17.    privatestaticString childStaticField ="child static field";
  18.    static{
  19.        System.out.println(childStaticField);
  20.        System.out.println("child static block");
  21.    }
  22.    privateString childField ="child member field";
  23.    {
  24.        System.out.println(childField);
  25.        System.out.println("child non-static block");
  26.    }
  27.    publicChild(){
  28.        System.out.println("child constructor");
  29.    }
  30.    publicstaticvoid main(String[] args){
  31.        newChild();
  32.    }
  33. }
程序输出:
  1. parent static field
  2. parent static block
  3. child static field
  4. child static block
  5. parent member field
  6. parent non-static block
  7. parent constructor
  8. child member field
  9. child non-static block
  10. child constructor
可以得出以下结论:
父类静态变量 > 父类静态初始块 > 子类静态变量 > 子类静态初始块 > 父类成员变量 > 父类非静态初始块 > 父类构造器 > 子类成员变量 > 子类非静态初始块 > 子类构造器

示例3:测试成员变量、初始块的初始化顺序

从上面两个例子可以看出,父类的静态变量和静态初始块肯定是先于子类加载的。但同一个类中的静态变量与静态初始块之间,成员变量与初始块之间的顺序一定是变量先于初始块吗?继续演示!
  1. publicclassTestOrder{
  2.    privatestatic A a =new A();
  3.    static{
  4.        System.out.println("static block");
  5.    }
  6.    privatestatic B b =new B();
  7.    publicstaticvoid main(String[] args){
  8.        newTestOrder();
  9.    }
  10. }
  11. class A {
  12.    public A(){
  13.        System.out.println("static field A");
  14.    }
  15. }
  16. class B {
  17.    public B(){
  18.        System.out.println("static field B");
  19.    }
  20. }
程序输出:
  1. static field A
  2. static block
  3. static field B
可以得出以下结论:
静态变量A > 静态初始块 > 静态变量B
所以,它们的在类中的顺序就决定了它们的初始化顺序,而不是变量一定会优先于初始块。

本站所有文章均来自互联网,如有侵权,请联系站长删除。极客文库 » 类、变量、块、构造器、继承初始化顺序,终极解答。
分享到:
赞(0)

评论抢沙发

评论前必须登录!