A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 秦冲 黑马帝   /  2012-5-29 19:42  /  3661 人查看  /  7 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 秦冲 于 2012-5-29 19:44 编辑
  1. public enum Test {
  2.           A,B,C,D;
  3.          public static int i=11;
  4.          private Test(){
  5.           i=33;
  6.       }
  7. }
复制代码
初始化访问 i 没声明?又是顺序。。

7 个回复

倒序浏览
枚举和类是一个级别的,都是需要建立对象的,你静态是和类或者枚举文件一起加载到内存中的,所以构造函数里面不能写关于静态的内容
回复 使用道具 举报
丰亚彬 发表于 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
回复 使用道具 举报
本帖最后由 李哲 于 2012-5-29 21:52 编辑

不好意思。
回复 使用道具 举报
本帖最后由 李哲 于 2012-5-29 21:51 编辑

多发一遍。
回复 使用道具 举报
本帖最后由 李哲 于 2012-5-29 21:50 编辑

我思考很久,只能给出一个猜测。
  1. public enum Test {
  2.    A,B;
  3.    public static  int i=5;  
  4.    private Test(){           
  5.            System.out.println("hehe");
  6.    }
  7. }

  8. class Ko {   
  9.    public static int i=6;
  10.    Ko(){                     
  11.            System.out.println("haha");
  12.    }
  13. }
  14. public class EnumTest {

  15.         /**
  16.          * @param args
  17.          */
  18.         public static void main(String[] args) {

  19.                 System.out.println(Test.i);
  20.                 System.out.println(Ko.i);
  21.         }


  22. }
复制代码
hehe
hehe
5
6

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

点评

在结合我先前发的贴 类的初始化顺序,你应该找到核心了。  发表于 2012-5-29 21:55
回复 使用道具 举报
李哲 中级黑马 2012-5-29 22:29:51
7#
李哲 发表于 2012-5-29 21:39
我思考很久,只能给出一个猜测。hehe
hehe
5

哈哈。多谢指点。
回复 使用道具 举报
王亚男 黑马帝 2012-5-30 03:06:55
8#
枚举常量初始化时会调用到构造函数,因为隐式语句就是 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。

又跟你们学了很多东西,感激不尽。这也只是我的推论,不对的地方请一定告知,也请勿见笑。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马