1.先贴代码

1. public class DemoClass
   
2. {
   
3.    
   
4.     /**
   
5.      * @param args the command line arguments
   
6.      */
   
7.     public static void main(String[] args)
   
8.     {
   
9.         // TODO code application logic here
   
10.         new Demo().show();
    
11.     }
    
12.    
    
13. }
    
14. class Demo
    
15. {
    
16.     // 静态变量显示初始化
    
17.     private static int a = 3;
    
18.    
    
19.     // 实例成员变量
    
20.     private String string = "实例变量显式初始化";
    
21.    
    
22.     static
    
23.     {
    
24.         System.out.println(a); // 输出结果为3，说明静态变量的初始化在静态代码块之前。
    
25.     }
    
26.    
    
27.     {
    
28.         System.out.println(string);
    
29.         // 输出结果为实例变量，说明实例对象的显示初始化在非静态代码块之前。
    
30.     }
    
31.    
    
32.     public Demo()
    
33.     {
    
34.         // 构造函数中对string 进行操作。
    
35.         this.string = "构造函数";
    
36.     }
    
37.    
    
38.     public void show()
    
39.     {
    
40.         // 显示string 的最终结果
    
41.         System.out.println(string);
    
42.     }
    
43. }

复制代码

2.程序输出

3.结论
1.从文件中加载Demo类到内存中
2.静态变量显式初始化
3.执行类的静态代码块
4.在堆中分配内存空间给非静态变量
5.对非静态变量进行默认初始化
6.对非静态变量进行显式初始化
7调用非静态代码块（构造代码块）
8调用构造函数进行特定初始化

4.求证：
求教大家：类中成员的初始化顺序是结论中那样的吗？谢谢！

2与3我验证过没有谁先谁后之说，谁写在前面谁先执行

有时候 太细了 就纠结了，正真应该站在项目的高度

跟老毕说的差不多，有一点不对，静态代码块和静态变量的顺序取决于代码的先后。谁在前面，谁先运行
看代码
class demo3{
        public static int x=3;
        static{
                System.out.println(x);         
                System.out.println("静态代码块");
        }
}
结果:3先运行
class demo3{       
        static{                 
                System.out.println("静态代码块");
        }
        public static int x=3;
        static{
                System.out.println(3);
        }       
}
结果：静态代码块先运行。

谭荣强 发表于 2014-6-10 02:31
跟老毕说的差不多，有一点不对，静态代码块和静态变量的顺序取决于代码的先后。谁在前面，谁先运行
看代码
...

多谢您了！

cain 发表于 2014-6-10 00:46
有时候 太细了 就纠结了，正真应该站在项目的高度

学习阶段，我想扣细点，不然出了问题不知道原因。

java木 发表于 2014-6-10 00:27
2与3我验证过没有谁先谁后之说，谁写在前面谁先执行

不操作静态变量的话确实没什么先后之分。

1. package test;
   
2. 
   
3. 
   
4. /**
   
5. * @author Administrator
   
6. *测试类成员的初始化的顺序
   
7. */
   
8. public class InitClassMemberSquenceTest
   
9. {
   
10.    
    
11.     /**
    
12.      * @param args the command line arguments
    
13.      *1.从文件中加载Demo类到内存中
    
14.      *2.静态变量显式初始化(或执行类的静态代码块，与它们在程序中被调用的位置有关)
    
15.          *3.执行类的静态代码块(或静态变量显式初始化，与它们在程序中的被调用位置有关)
    
16.          *4.在堆中分配内存空间给非静态变量
    
17.          *5.对非静态变量进行默认初始化(或对非静态变量进行显式初始化，与它们在程序中被调用的位置有关)
    
18.          *6.对非静态变量进行显式初始化(对非静态变量进行默认初始化，与它们在程序中被调用的位置有关)
    
19.          *7.调用非静态代码块（构造代码块）
    
20.          *8.调用构造函数进行特定初始化
    
21.      */
    
22.     public static void main(String[] args)
    
23.     {
    
24.         // TODO code application logic here
    
25.         new Demo().show();
    
26.     }
    
27.    
    
28. }
    
29. class Demo
    
30. {
    
31.     // 静态变量显示初始化
    
32.     private static int a = 3;
    
33.    
    
34.     // 实例成员变量
    
35.     private String string ="实例变量显式初始化";
    
36.     private int i;
    
37.    
    
38.     static
    
39.     {       
    
40.             System.out.println("静态代码块"); // 静态变量的初始化和静态代码块的执行顺序只与它们在程序中的书写顺序有关，没有指定的先后之分
    
41.         System.out.println(a); //
    
42.        // System.out.println("静态代码块");
    
43.     }
    
44.     /*
    
45.     {
    
46.         System.out.println(i);
    
47.         // 输出结果为0，对非静态变量进行默认初始化
    
48.     }
    
49.     */
    
50.     {
    
51.         System.out.println(string);
    
52.         // 输出结果为实例变量，说明实例对象的显示初始化在非静态代码块之前。
    
53.     }
    
54.    
    
55.    
    
56.     {
    
57.         System.out.println(i);
    
58.         // 输出结果为0，对非静态变量进行默认初始化
    
59.     }
    
60.    
    
61.     public Demo()
    
62.     {
    
63.         // 构造函数中对string 进行操作。
    
64.         this.string = "构造函数";
    
65.     }
    
66.    
    
67.     public void show()
    
68.     {
    
69.         // 显示string 的最终结果
    
70.         System.out.println(string);
    
71.     }
    
72. }

复制代码