java中类的静态代码块、构造代码块、构造方法、静态成员的初始化顺序详解

一、描述

java中类的静态代码块、构造代码块、构造方法、静态成员的初始化顺序：

  首先，在类加载时，为类中的静态成员变量分配内存空间，并为其赋予默认值(整数型为0，浮点型为0.0，布尔型为false，字符型为'\u0000'，引用型为null)；

  其次，执行静态成员变量的显式初始化操作。静态成员的初始化方法有两种，其一为在声明的时候直接初始化，其二为使用静态代码块进行初始化，

 这两种初始化方式会按照在类中的出现顺序来执行，而且只在类加载的时候执行一次。

  再次，如果创建了类的对象，便会在堆中为类的实例分配内存空间，实例变量也会被初始化为默认值(默认值与静态成员的默认值xiangtong)。

  再次，执行实例变量的显式初始化操作，其中包含两种初始化操作，其一为声明时直接初始化，其二为在构造代码块中进行初始化，这两种初始化方法也按照出现的先后次序来依次执行。 

最后，执行类的构造方法，构造方法是每创建一个对象就调用一次，可以进行多次调用。

 总结：在类加载时，先按照静态成员变量或者静态代码块的出现次序来初始化静态成员（类加载时只执行一次）；

 然后按照普通成员变量和构造代码块的出现顺序来初始化普通成员变量（创建几个对象执行几次）；

 最后调用类的构造方法，对成员变量进行初始化（创建几个对象执行几次）。

 执行优先次序：静态成员和静态代码块 > 成员变量和构造代码块 > 构造方法

二、源代码

[java]  view plain copy

1. <span style="font-size:18px;">package tong.yue.day4_25;  
2. /** 
3.  * java中类的静态代码块、构造代码块、构造方法、静态成员的初始化顺序： 
4.  * 首先，在类加载时，为类中的静态成员变量分配内存空间，并为其赋予默认值(整数型为0，浮点型为0.0，布尔型为false，字符型为'\u0000'，引用型为null)； 
5.  * 其次，执行静态成员变量的显式初始化操作。静态成员的初始化方法有两种，其一为在声明的时候直接初始化，其二为使用静态代码块进行初始化， 
6.  * 这两种初始化方式会按照在类中的出现顺序来执行，而且只在类加载的时候执行一次。 
7.  * 再次，如果创建了类的对象，便会在堆中为类的实例分配内存空间，实例变量也会被初始化为默认值(默认值与静态成员的默认值xiangtong)。 
8.  * 再次，执行实例变量的显式初始化操作，其中包含两种初始化操作，其一为声明时直接初始化，其二为在构造代码块中进行初始化，这两种初始化方法也按照出现的先后次序来依次执行。 
9.  * 最后，执行类的构造方法，构造方法是每创建一个对象就调用一次，可以进行多次调用。 
10.  *  
11.  * 总结：在类加载时，先按照静态成员变量或者静态代码块的出现次序来初始化静态成员（类加载时只执行一次）； 
12.  * 然后按照普通成员变量和构造代码块的出现顺序来初始化普通成员变量（创建几个对象执行几次）； 
13.  * 最后调用类的构造方法，对成员变量进行初始化（创建几个对象执行几次）。 
14.  * 执行优先次序：静态成员和静态代码块 > 成员变量和构造代码块 > 构造方法 
15.  *  
16.  * @author tong 
17.  * 
18.  */  
19. public class Car {  
20.     // 有参构造器1  
21.     public Car(String color) {  
22.         System.out.println("执行构造器Car(String)");  
23.         this.color = color;  
24.     }  
25.   
26.     // 构造代码块1  
27.     {  
28.         System.out.println("执行初始化块1");  
29.     }  
30.     // 静态初始化块1  
31.     static {  
32.         System.out.println("执行静态初始化块1");  
33.         length = 3.2;  
34.     }  
35.   
36.     // 实例变量直接初始化  
37.     private String color = getColor();  
38.     // 静态成员变量直接初始化  
39.     private static double length = getLength();  
40.   
41.     // // 构造代码块2  
42.     {  
43.         System.out.println("执行初始化块2");  
44.     }  
45.       
46.     // 静态初始化块2  
47.     static {  
48.         System.out.println("执行静态初始化块2");  
49.         length = 3.2;  
50.     }  
51.     //静态成员变量初始化  
52.     private static double width = getWidth();  
53.     //普通成员变量初始化  
54.     private int maxSpeed = getMaxSpeed();  
55.     //无参构造器2  
56.     public Car() {  
57.         System.out.println("执行构造器Car()");  
58.         color = "red";  
59.     }  
60.     //普通成员方法，获取maxSpeed  
61.     private int getMaxSpeed() {  
62.         System.out.println("初始化成员变量speed");  
63.         return 180;  
64.     }  
65.     //静态成员方法，获取width  
66.     private static double getWidth() {  
67.         System.out.println("初始化静态成员变量width");  
68.         return 2.0;  
69.     }  
70.     //静态成员方法，获取length  
71.     private static double getLength() {  
72.         System.out.println("初始化静态成员变量length");  
73.         return 3.2;  
74.     }  
75.     //普通成员方法，获取color  
76.     private String getColor() {  
77.         System.out.println("初始化实例变量color");  
78.         return color;  
79.     }  
80.   
81.     public static void main(String[] args) {  
82.         new Car();  //调用无参构造方法创建对象  
83.         new Car("red");   //调用有参构造方法创建对象  
84.   
85.     }  
86. }  
87. </span>  

执行结果：

三、总结

1、静态成员和静态代码块两个同类出现的顺序决定了初始化顺序，它们的执行一定先于普通成员变量初始化、构造代码块初始化和构造函数；

2、普通成员和普通构造代码块两者在代码中的出现顺序决定了初始化顺序，它们的执行一定后于静态成员和静态代码块，但是先于构造方法；

3、与上面两者相比，构造函数永远是最后执行的。