package cn.itcast.day1;

enum Week {
MON("java01"),TUE("java02"),WED("java03"),THU("java04"),FRI("java05"),SAT("java06"),SUN("rest");
String study;
public void printStudy(){
System.out.println(this.study);
}
Week(String study){
this.study=study;
this.printStudy();

}
}

public class TestWeek {

public static void main(String[] args) {
Week day1=Week.SAT;//在这里我只调用了一个枚举的实例对象，为什么却把所有的枚举对象的属性值都给打印出来了呀？

}
}
打印结果：
java01
java02
java03
java04
java05
java06
rest

Week day1=Week.SAT创建一个对象day1.内存中会把Week加载进来。再看枚举中定义的方法printStudy()
这个意思是把Week枚举对应的study进行打印，相当于把里面定义的MON("java01"),TUE("java02"),WED("java03"),THU("java04"),FRI("java05"),SAT("java06"),SUN("rest");
对应的study都输出。
增加两行代码分析原因。
enum Week {
        MON("java01"),TUE("java02"),WED("java03"),
        THU("java04"),FRI("java05"),SAT("java06"),SUN("rest");
        String study;
        public void printStudy(){
                System.out.println(this.study+"++"+this.getClass());        }
        Week(String study){
                this.study=study;
                this.printStudy();       
        }
}
public class TestWeek {
public static void main(String[] args) {
                Week day1=Week.SAT;
                System.out.println("------");
                Week day2=Week.SUN;
                System.out.println("------");
                System.out.println(day1);
                //在这里我只调用了一个枚举的实例对象，为什么却把所有的枚举对象的属性值都给打印出来了呀？

        }
}
我在主函数中新增了实例，但是并不会再答应一遍属性，说明肯定是第一次创建对象的时候就加载到内存中了。
打印结果：
java01++class testing2.Week
java02++class testing2.Week
java03++class testing2.Week
java04++class testing2.Week
java05++class testing2.Week
java06++class testing2.Week
rest++class testing2.Week
------
------
SAT

当你使用这个枚举时，JVM会去加载它，在加载后会对所有的枚举对象进行初始化。

韦念欣 发表于 2012-7-16 09:44
当你使用这个枚举时，JVM会去加载它，在加载后会对所有的枚举对象进行初始化。 ...

你看看是不是可以这样理解：
枚举类型的每一个成员都是一个实例，默认的声明都是public static final 。
在调用者者枚举时，枚举中的美一个成员都会被加载到方法区中。

只要你用到枚举类，静态成员变量都会初始化，静态代码都会执行，执行的时候构造方法都会调用，在构造方法里就会打印出这些参数。结合下面的例子看
//在使用枚举时，定义常量实际上是当前类静态常量对象
//(1)用普通类模拟枚举，首先该类的构造方法应该是私有的
public final static TrafficLight RED=new TrafficLight(30){ // 创建了一个对象，由于是静态常量对象，类加载时会自动调用构造函数

@Override
public TrafficLight nextLight() {
return GREEN;
}

1. public abstract class TrafficLight {
   
2. //在使用枚举时，定义常量实际上是当前类静态常量对象
   
3. //(1)用普通类模拟枚举，首先该类的构造方法应该是私有的
   
4. private int time;
   
5. 
   
6. private TrafficLight(){};
   
7. 
   
8. private TrafficLight(int time){
   
9. this.time=time;
   
10. }
    
11. //定义RED,GREEN,YELLOW当前类的静态常量对象
    
12. public final static TrafficLight RED=new TrafficLight(30){
    
13. 
    
14. @Override
    
15. public TrafficLight nextLight() {
    
16. return GREEN;
    
17. }
    
18. 
    
19. @Override
    
20. public String toString() {
    
21. return "RED";
    
22. }
    
23. 
    
24. };
    
25. 
    
26. public final static TrafficLight GREEN=new TrafficLight(45){
    
27. 
    
28. @Override
    
29. public TrafficLight nextLight() {
    
30. return YELLOW;
    
31. }
    
32. 
    
33. @Override
    
34. public String toString() {
    
35. return "YELLOW";
    
36. }
    
37. 
    
38. };
    
39. //这是通过匿名内部内来实现的
    
40. public final static TrafficLight YELLOW=new TrafficLight(){
    
41. 
    
42. @Override
    
43. public TrafficLight nextLight() {
    
44. return RED;
    
45. }
    
46. 
    
47. @Override
    
48. public String toString() {
    
49. return "RED";
    
50. }
    
51. 
    
52. };
    
53. 
    
54. //当我们在使用这个类时, 不可能再随随便便来创建其他对象，（我们只能选择上面三个对象的其中之一），这就是枚举实现思想
    
55. public abstract String toString();
    
56. //父类的抽象方法有子类来实现
    
57. public abstract TrafficLight nextLight();
    
58. 
    
59. public static void main(String args[]){
    
60. System.out.println(RED.nextLight());
    
61. }
    
62. }
    

复制代码