1. public enum Test {
   
2.           A,B,C,D；
   
3.          public static int i=11;
   
4.          private Test(){
   
5.           i=33;
   
6.       }
   
7. }

复制代码

初始化访问 i 没声明？又是顺序。。

枚举和类是一个级别的，都是需要建立对象的，你静态是和类或者枚举文件一起加载到内存中的，所以构造函数里面不能写关于静态的内容

丰亚彬 发表于 2012-5-29 20:13
枚举和类是一个级别的，都是需要建立对象的，你静态是和类或者枚举文件一起加载到内存中的，所以构造函数里 ...

1. public class Test{
   
2.         public static int i = 5;
   
3.     public Test() {
   
4.                 System.out.println(i);;
   
5.         }       
   
6.     public static void main(String[] args) {
   
7.                 Test t = new Test();
   
8.         }
   
9. }

复制代码

输出 5

不好意思。

多发一遍。

我思考很久，只能给出一个猜测。

1. public enum Test {
   
2.    A,B;
   
3.    public static  int i=5;  
   
4.    private Test(){           
   
5.            System.out.println("hehe");
   
6.    }
   
7. }
   
8. 
   
9. class Ko {   
   
10.    public static int i=6;
    
11.    Ko(){                     
    
12.            System.out.println("haha");
    
13.    }
    
14. }
    
15. public class EnumTest {
    
16. 
    
17.         /**
    
18.          * @param args
    
19.          */
    
20.         public static void main(String[] args) {
    
21. 
    
22.                 System.out.println(Test.i);
    
23.                 System.out.println(Ko.i);
    
24.         }
    
25. 
    
26. 
    
27. }

复制代码

hehe
hehe
5
6

注意没有haha。也就是说，对于枚举来说，调用属性i之前必须先调用构造函数，而类则不同。我怀疑枚举的构造函数先于或者同时和静态的属性i出现在内存中，这样构造函数是没法调用属性i的。为什么这么说？有一点是不用怀疑的，那就是枚举的元素A和B都是public static final类型，并不比static的属性i 晚出现。而要出现A和B就要使用构造函数。

李哲 发表于 2012-5-29 21:39
我思考很久，只能给出一个猜测。hehe
hehe
5

哈哈。多谢指点。

枚举常量初始化时会调用到构造函数，因为隐式语句就是 public static final Test A = new Test();  而枚举常量本身的类型是public static final且它们一定会在枚举中的最前面，优先级不比本例中的 i 低，所以应该会按照顺序来初始化。
用一个普通类来模拟下从而证明这个结论的话，就是：

1. class Enum{
   
2.        
   
3.         public static final Enum A = new Enum();
   
4.         public static final Enum B = new Enum();
   
5.         public static int i = 3;
   
6.        
   
7.        
   
8.         Enum(){
   
9.                 System.out.println(i);
   
10.         }
    
11. }
    
12. class Test{
    
13.         public static void main(String[] args){
    
14.                 new Enum();       
    
15.         }
    
16.        
    
17. }

复制代码

打印的结果是 0 0 3 。
但如果把public static int i = 3;放到第一行时，结果又会变为3 3 3。但在枚举中，这是不允许的。
但在普通类中，还可以访问到尚未显式初始化的i。枚举中却不可以。所以，枚举和普通类在内存加载上还是存在着差别。这样，楼上兄台的猜想“我怀疑枚举的构造函数先于或者同时和静态的属性i出现在内存中”应该是成立的。只是，先于静态属性i的可能性大些。如果说是同时，应该和类一样，至少可以访问默认初始化的i。

又跟你们学了很多东西，感激不尽。这也只是我的推论，不对的地方请一定告知，也请勿见笑。