Java初始化顺序

普通类初始化

 1 package com.fwj.init;
 2 
 3 public class Sample {
 4 
 5     Sample(String s){
 6           System.out.println(s);
 7     }
 8     Sample(){
 9           System.out.println("Sample默认构造函数被调用");
10     }
11 }

 1 package com.fwj.init;
 2 
 3 public class Test {
 4     static Sample sam=new Sample("静态成员sam初始化");
 5     Sample sam1=new Sample("sam1成员初始化");
 6     static{
 7           System.out.println("static块执行");
 8 
 9           if(sam==null)System.out.println("sam is null");
10 
11           sam=new Sample("静态块内初始化sam成员变量");
12 
13           }
14     Test(){
15           System.out.println("Test默认构造函数被调用");
16     }
17     public static void main(String[] args) {
18         new Test();
19     }
20 }

运行结果：

静态成员sam初始化
static块执行
静态块内初始化sam成员变量
sam1成员初始化
Test默认构造函数被调用

结论：

1、静态成员首先初始化

2、普通成员初始化

3、构造函数初始化

对于静态成员之间和普通成员之间的初始化顺序，之和他们的定义顺序有关：

 1 package com.fwj.init;
 2 
 3 public class Test {
 4     static{
 5         System.out.println("static 块 1  执行");
 6         }
 7   static Sample staticSam1=new Sample("静态成员staticSam1初始化");
 8   Sample sam1=new Sample("sam1成员初始化");
 9   static Sample staticSam2=new Sample("静态成员staticSam2初始化");
10   static{
11         System.out.println("static 块 2  执行");
12 
13         }
14   Test(){
15         System.out.println("Test默认构造函数被调用");
16   }
17   Sample sam2=new Sample("sam2成员初始化");
18   
19   public static void main(String[] args) {
20         new Test();
21   }
22 }

执行结果：

static 块 1  执行
静态成员staticSam1初始化
静态成员staticSam2初始化
static 块 2  执行
sam1成员初始化
sam2成员初始化
Test默认构造函数被调用

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

 1 package com.fwj.init;
 2 
 3 public class Test {
 4     static {
 5         System.out.println("父类static 块 1  执行");
 6     }
 7 
 8     static Sample staticSam1 = new Sample("父类 静态成员staticSam1初始化");
 9     Sample sam1 = new Sample("父类 sam1成员初始化");
10     static Sample staticSam2 = new Sample("父类 静态成员staticSam2初始化");
11     
12     static {
13         System.out.println("父类 static 块 2  执行");
14 
15     }
16 
17     Test(){
18         System.out.println("父类 Test默认构造函数被调用");
19     }
20     Sample sam2 = new Sample("父类 sam2成员初始化");
21 }

 1 package com.fwj.init;
 2 
 3 public class TestSub extends Test {
 4 
 5     static Sample staticSamSub = new Sample("子类 静态成员staticSamSub初始化");
 6 
 7     TestSub()
 8     {
 9         System.out.println("子类 TestSub 默认构造函数被调用");
10     }
11 
12     Sample sam1 = new Sample("子类 sam1成员初始化");
13     static Sample staticSamSub1 = new Sample("子类 静态成员staticSamSub1初始化");
14     
15     static {
16         System.out.println("子类 static 块  执行");
17     }
18     
19     Sample sam2 = new Sample("子类 sam2成员初始化");
20 
21     public static void main(String[] args) {
22         new TestSub();
23     }
24 
25 }

运行结果：

父类static 块 1  执行
父类 静态成员staticSam1初始化
父类 静态成员staticSam2初始化
父类 static 块 2  执行
子类 静态成员staticSamSub初始化
子类 静态成员staticSamSub1初始化
子类 static 块  执行
父类 sam1成员初始化
父类 sam2成员初始化
父类 Test默认构造函数被调用
子类 sam1成员初始化
子类 sam2成员初始化
子类 TestSub 默认构造函数被调用

结论：

1、继承体系的所有静态成员初始化，先父类，后子类。

2、父类完成初始化，普通成员初始化---》构造方法初始化

3、子类完成初始化，普通成员初始化---》构造方法初始化

引用：http://www.cnblogs.com/miniwiki/archive/2011/03/25/1995615.html

posted on 2013-07-29 10:49 Joyen.fu 阅读(234) 评论(0) 编辑收藏举报