1. public class Test1 {
   
2.    {
   
3.          a = 1;
   
4.          System.out.println(a);//这里会抛错。
   
5.      }
   
6.       private int a;
   
7.      public static void main(String[] args){
   
8.      Test1 test1 = new Test1();
   
9.      System.out.println(test1.a);
   
10.     }
    
11. }
    
12. --------------------------------------------------------
    
13. 报错
    
14. public class Test6 {
    
15. 
    
16.      {
    
17.          a = 4;
    
18.      }
    
19. 
    
20.      private static final int a;
    
21. 
    
22.      public static void main(String[] args){
    
23.               System.out.println(a);
    
24.      }
    
25. }
    
26. --------------------------------------------------------
    
27. 这个又没有问题
    
28. public class Test7 {
    
29. 
    
30.    static{
    
31.           a = 5;
    
32.       }
    
33. 
    
34.        private static final int a;
    
35. 
    
36. 
    
37.        public static void main(String[] args){
    
38.          System.out.println(a);
    
39.      }
    
40. }
    
41. =========================一下子，变量初始化把我搞晕了，test1和test6为什么报错，test7为什么又没有问题？？？？

复制代码

1. /*
   
2. 问题在于构造代码块、静态代码块和对象的加载顺序，
   
3. 并且要明确构造代码块只有对象存在时才会执行：
   
4. 
   
5. 对于Test1：构造代码块是给对象进行初始化，运行时，
   
6. 对象中的成员变量private int a根本还没有进内存；
   
7. 所以楼主可以用我修改过的方法来验证：
   
8. 
   
9. 对于Test6: 若变量一被声明为final,则它的值就不可再改变，
   
10. 并且，楼主要注意的是：构造代码块只有存在对象时才执行，并且，
    
11. 静态变量先于对象存在于一个单独的静态区中，所以，楼主可以用我在以下
    
12. 修改的方法中进行验证：
    
13. 
    
14. 对于Test7:是因为静态成员变量int a先于对象存在于静态区中，静态代码块：
    
15. static{}也先于对象存在，并是给主函数进行初始化，所以，可以执行正确，
    
16. 但是，若是将a声明为final则同样会报错；
    
17. 
    
18. 如下注释：
    
19. 
    
20. */
    
21. class Test1 {
    
22.          //先运行构造代码块(因为主函数中创建了对象)，此时，对象中的成员变量private int a还未加载；
    
23.          {        int a;//给a指定数据类型
    
24.          a = 1;
    
25.          System.out.println(a);
    
26.      }
    
27.       private  int a;//-->这里运行后是0；
    
28.      public static void main(String[] args)
    
29.         {
    
30.      Test1 test1 = new Test1();
    
31.      System.out.println(test1.a);
    
32.     }
    
33. }
    
34. 
    
35. --------------------------------------------------------
    
36. 
    
37. class Test6 {
    
38. 
    
39.      { //静态代码块执行之前，静态区中已经存在静态变量a
    
40.        a = 4;
    
41.                 System.out.println("test:"+a);
    
42.      }
    
43. 
    
44.      private  static /*final*/ int  a=3;//若变量一被声明为final则不可再改变；
    
45. 
    
46.      public static void main(String[] args)
    
47.         {
    
48.               System.out.println("hh"+new Test6().a);
    
49.     }
    
50. }
    
51. 
    
52. --------------------------------------------------------
    
53. class Test7 {
    
54. 
    
55.    static{
    
56.           a = 5;
    
57.       }
    
58. 
    
59.        private static final int a;
    
60.            /*如果这里指定了a的值，如private Static final int a=9;
    
61.            那么就会出错因为final变量的值不可再改变
    
62.            */
    
63. 
    
64.        public static void main(String[] args)
    
65.         {
    
66.          System.out.println(a);
    
67.      }
    
68. }

复制代码

给你看一个例子

1. class StaticCode
   
2. {
   
3.         StaticCode()
   
4.         {
   
5.                 System.out.println("a");
   
6.         }
   
7.         static//静态代码块，用于给类初始化
   
8.         {
   
9.                 System.out.println("b");
   
10.         }
    
11.         {//构造代码块，给对象初值化
    
12.                 System.out.println("c");
    
13.         }
    
14.         StaticCode(int x)
    
15.         {
    
16.                 System.out.println("d");
    
17.         }
    
18.         public static void main(String[] args)
    
19.         {
    
20.                 new StaticCode(4);
    
21.         }
    
22. }
    

复制代码

打印结果：
b
c
d

貌似里清了顺序，感谢大家