Java类变量和成员变量初始化过程

一、类的初始化

对于类的初始化：类的初始化一般只初始化一次，类的初始化主要是初始化静态成员变量。

类的编译决定了类的初始化过程。

编译器生成的class文件主要对定义在源文件中的类进行了如下的更改：

1) 先按照静态成员变量的定义顺序在类内部声明成员变量。

2) 再按照原java类中对成员变量的初始化顺序进行初始化。

一个java类和编译后的class对应的转换如下：

源文件：

1. public class Person{  
2. public static String name="张三";  
3. public static int age;  
4. static{  
5.        age=20;  
6. System.out.println("初始化age");  
7. }  
8. public static String address;  
9. static{  
10. address="北京市";  
11. age=34;  
12. }  
13. public static void main(String[] args) {  
14.                    System.out.println(name);  
15.                    System.out.println(age);  
16.                    System.out.println(address);  
17.          }  
18. } 

当java源代码转换成一个class文件后，其转换成类似下面的代码：

1. public class Person{  
2. public static String name;  
3. public static int age;  
4. public static String address;  
5. static{  
6. name="张三";  
7. age=20;  
8. System.out.println("初始化age");  
9. address="北京市";  
10. age=34;  
11. }  
12. public static void main(String[] args) {  
13.                    System.out.println(name);  
14.                    System.out.println(age);  
15.                    System.out.println(address);  
16.          }  
17. } 

初始化顺序依据转换后对应的class类成员变量的初始化顺序依次执行，所以所有的静态成员变量都是先声明，后执行赋值的，而且赋值的顺序也是依照源代码对静态成员变量初始化的顺序进行的，注意：定义一个成员变量并直接初始化与在静态代码块中进行初始化是等价的，都是依据它们在源代码中定义的顺序进行的。

 

二、对象的生成

对于对象的生成其初始化过程与类的初始化过程类似，但会增加构造函数阶段，源代码如下：

1. public class Person{  
2.  {  
3.  name="李四";  
4.  age=56;  
5.  System.out.println("初始化age");  
6.  address="上海";  
7.  }  
8.  public String name="张三";  
9.  public int age=29;  
10.  public String address="北京市";  
11.  public Person(){  
12.  name="赵六";  
13.  age=23;  
14.  address="上海市";  
15.  }  
16.  } 

编译器转换成class文件后，会转换成类似下面的代码：

1. public class Person{  
2.  public String name;  
3.  public int age;  
4.  public String address;  
5.  public Person(){  
6.  name="李四";  
7.  age=56;  
8.  System.out.println("初始化age");  
9.  address="上海";  
10.  name="张三";  
11.  age=29;  
12.  address="北京市";  
13.  name="赵六";  
14.  age=23;  
15.  address="上海市";  
16.  }  
17.  } 

可以看到，对于类中对成员变量的初始化和代码块中的代码全部都挪到了构造函数中，并且是按照java源文件的初始化顺序依次对成员变量进行初始化的，而原构造函数中的代码则移到了构造函数的最后执行。本人以前一直对类初始化过程一直没有一个深刻的理解，就是搞不清到底是怎么初始化的，只能按照书上所说的记住了初始化顺序，但是过一段时间有给忘了，所以这次总算给弄清楚了，还是按照一个模型来解释初始化机制比较好啊，不用再背了，只有理解了才能不易忘。