java中初始化顺序（转）

http://blog.csdn.net/fangof/article/details/4844514

 

2009-11-20 21:57 42人阅读 评论(0) 收藏举报

（1）初始化的顺序（静态、非静态、final、变量、对象）

    对于静态变量、静态初始化块、变量、初始化块、构造器，它们的初始化顺序依次是（静态变量、静态初始化块,此处按照排列顺序，在类的初始化阶段完成）>（变量、初始化块，在实例化时候完成）>构造器。

我们也可以通过下面的测试代码来验证这一点：

 

package com.cisco.test;

class P{
 
 private static int t=print(1);
 private int x;
 
 static{
  print(2);
 }
 
 private static int z=print(3);

 
 public P(int x) {
  this.x=x;
  print(5);
  }

 public static int print(int x) {
  
  System.out.println("step"+x);
  return x;
   }
}

public class S extends P{
 
 private static int t=print(4);

 public S(int x) {
  super(x);
  print(6);
  
  }

 /**
  * @param args
  */
 public static void main(String[] args) {
  
  new S(10);
 
 }

}

 

 

 

Java代码：

[c-sharp] view plaincopyprint?

1. public class InitialOrderTest {  
2.   
3.    
4.   
5.   // 静态变量   
6.   
7.   public static String staticField = "静态变量";  
8.   
9.   // 变量   
10.   
11.   public String field = "变量";  
12.   
13.    
14.   
15.   // 静态初始化块   
16.   
17.   static {  
18.   
19.    System.out.println(staticField);  
20.   
21.    System.out.println("静态初始化块");  
22.   
23.   }  
24.   
25.    
26.   
27.   // 初始化块   
28.   
29.   {  
30.   
31.    System.out.println(field);  
32.   
33.    System.out.println("初始化块");  
34.   
35.   }  
36.   
37.    
38.   
39.   // 构造器   
40.   
41.   public InitialOrderTest() {  
42.   
43.    System.out.println("构造器");  
44.   
45.   }  
46.   
47.    
48.   
49.   public static void main(String[] args) {  
50.   
51.    new InitialOrderTest();  
52.   
53.   }  
54.   
55. }  

public class InitialOrderTest { // 静态变量 public static String staticField = "静态变量"; // 变量 public String field = "变量"; // 静态初始化块 static { System.out.println(staticField); System.out.println("静态初始化块"); } // 初始化块 { System.out.println(field); System.out.println("初始化块"); } // 构造器 public InitialOrderTest() { System.out.println("构造器"); } public static void main(String[] args) { new InitialOrderTest(); }}

运行以上代码，我们会得到如下的输出结果：

1. 静态变量
2. 静态初始化块
3. 变量
4. 初始化块
5. 构造器

（2）初始化的顺序（子类、父类）

Java代码 ：

 

 

1. class Parent {   
2.     // 静态变量   
3.     public static String p_StaticField = "父类--静态变量";   
4.     // 变量   
5.     public String p_Field = "父类--变量";   
6.   
7.     // 静态初始化块   
8.     static {   
9.         System.out.println(p_StaticField);   
10.         System.out.println("父类--静态初始化块");   
11.     }   
12.   
13.     // 初始化块   
14.     {   
15.         System.out.println(p_Field);   
16.         System.out.println("父类--初始化块");   
17.     }   
18.   
19.     // 构造器   
20.     public Parent() {   
21.         System.out.println("父类--构造器");   
22.     }   
23. }   
24.   
25. public class SubClass extends Parent {   
26.     // 静态变量   
27.     public static String s_StaticField = "子类--静态变量";   
28.     // 变量   
29.     public String s_Field = "子类--变量";   
30.     // 静态初始化块   
31.     static {   
32.         System.out.println(s_StaticField);   
33.         System.out.println("子类--静态初始化块");   
34.     }   
35.     // 初始化块   
36.     {   
37.         System.out.println(s_Field);   
38.         System.out.println("子类--初始化块");   
39.     }   
40.   
41.     // 构造器   
42.     public SubClass() {   
43.         System.out.println("子类--构造器");   
44.     }   
45.   
46.     // 程序入口   
47.     public static void main(String[] args) {   
48.         new SubClass();   
49.     }   
50. }  

class Parent {

  // 静态变量

  public static String p_StaticField = "父类--静态变量";

  // 变量

  public String p_Field = "父类--变量";

 

  // 静态初始化块

  static {

   System.out.println(p_StaticField);

   System.out.println("父类--静态初始化块");

  }

 

  // 初始化块

  {

   System.out.println(p_Field);

   System.out.println("父类--初始化块");

  }

 

  // 构造器

  public Parent() {

   System.out.println("父类--构造器");

  }

}

 

public class SubClass extends Parent {

  // 静态变量

  public static String s_StaticField = "子类--静态变量";

  // 变量

  public String s_Field = "子类--变量";

  // 静态初始化块

  static {

   System.out.println(s_StaticField);

   System.out.println("子类--静态初始化块");

  }

  // 初始化块

  {

   System.out.println(s_Field);

   System.out.println("子类--初始化块");

  }

 

  // 构造器

  public SubClass() {

   System.out.println("子类--构造器");

  }

 

  // 程序入口

  public static void main(String[] args) {

   new SubClass();

  }

}

运行一下上面的代码，结果马上呈现在我们的眼前：

1. 父类--静态变量
2. 父类--静态初始化块
3. 子类--静态变量
4. 子类--静态初始化块
5. 父类--变量
6. 父类--初始化块
7. 父类--构造器
8. 子类--变量
9. 子类--初始化块
10. 子类--构造器

    现在，结果已经不言自明了。大家可能会注意到一点，那就是，并不是父类完全初始化完毕后才进行子类的初始化，实际上子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。

 

总结如下：

 

1．  父类静态成员和静态初始化块 ，按在代码中出现的顺序依次执行
2．  子类静态成员和静态初始化块 ，按在代码中出现的顺序依次执行
3．  父类实例成员和实例初始化块 ，按在代码中出现的顺序依次执行
4．  父类构造方法
5．  子类实例成员和实例初始化块 ，按在代码中出现的顺序依次执行
6．  子类构造方法 
 

    那么对于静态变量和静态初始化块之间、变量和初始化块之间的先后顺序又是怎样呢？是否静态变量总是先于静态初始化块，变量总是先于初始化块就被初始化了呢？实际上这取决于它们在类中出现的先后顺序。我们以静态变量和静态初始化块为例来进行说明。
同样，我们还是写一个类来进行测试：

Java代码

1. public class TestOrder {   
2.     // 静态变量   
3.     public static TestA a = new TestA();   
4.        
5.     // 静态初始化块   
6.     static {   
7.         System.out.println("静态初始化块");   
8.     }   
9.        
10.     // 静态变量   
11.     public static TestB b = new TestB();   
12.   
13.     public static void main(String[] args) {   
14.         new TestOrder();   
15.     }   
16. }   
17.   
18. class TestA {   
19.     public TestA() {   
20.         System.out.println("Test--A");   
21.     }   
22. }   
23.   
24. class TestB {   
25.     public TestB() {   
26.         System.out.println("Test--B");   
27.     }   
28. }  

public class TestOrder {

  // 静态变量

  public static TestA a = new TestA();

 

  // 静态初始化块

  static {

   System.out.println("静态初始化块");

  }

 

  // 静态变量

  public static TestB b = new TestB();

 

  public static void main(String[] args) {

   new TestOrder();

  }

}

 

class TestA {

  public TestA() {

   System.out.println("Test--A");

  }

}

 

class TestB {

  public TestB() {

   System.out.println("Test--B");

  }

}

运行上面的代码，会得到如下的结果：

1. Test--A
2. 静态初始化块
3. Test--B 

 

    大家可以随意改变变量a、变量b以及静态初始化块的前后位置，就会发现输出结果随着它们在类中出现的前后顺序而改变，这就说明静态变量和静态初始化块是依照他们在类中的定义顺序进行初始化的。同样，变量和初始化块也遵循这个规律。

数组和枚举的初始化且待下篇讨论。