枚举类也是一个类，当其中定义了一个抽象的方法时，为什么不用abstract修饰呢？

1. public enum TrafficLamp {
   
2.                 RED(30){
   
3. 
   
4.                         @Override
   
5.                         public TrafficLamp nextLamp() {
   
6.                                 // TODO Auto-generated method stub
   
7.                                 return GREEN;
   
8.                         }
   
9.                        
   
10.                 },
    
11.                 GREEN(45){
    
12. 
    
13.                         @Override
    
14.                         public TrafficLamp nextLamp() {
    
15.                                 // TODO Auto-generated method stub
    
16.                                 return YELLOW;
    
17.                         }},
    
18.                 YELLOW(5){
    
19. 
    
20.                         @Override
    
21.                         public TrafficLamp nextLamp() {
    
22.                                 // TODO Auto-generated method stub
    
23.                                 return RED;
    
24.                         }
    
25.                                
    
26.                         };
    
27.                 public abstract TrafficLamp nextLamp();//抽象方法
    
28.                 private int time;
    
29.                 private TrafficLamp(int time){this.time = time;}
    
30.                
    
31.         }
    

复制代码

详细说明一下哈。

在张孝祥老师关于java加强的视频中，讲到过一个普通的类如何定义成枚举类

1. public abstract class Day {
   
2.        
   
3.         private Day() {
   
4.         }
   
5. /**
   
6. * 采用抽象类将大量的ifelse转换成一个个的独立的类
   
7. */
   
8.                 public static final Day monday = new Day(){
   
9.                         @Override
   
10.                         public Day nextDay() {
    
11.                                 return thusday;
    
12.                         }
    
13.                 };
    
14.                 public static final Day thusday = new Day(){
    
15.                         @Override
    
16.                         public Day nextDay() {
    
17.                                 return null;
    
18.                         }
    
19.                 }
    
20.         public Day getDay()
    
21.         {
    
22.                 if(this == monday)
    
23.                 {
    
24.                         return monday;
    
25.                 }else
    
26.                 {
    
27.                         return thusday;       
    
28.                 }
    
29.         }
    
30.         public String toString()
    
31.         {
    
32.                 return null;
    
33.         }
    
34.         public abstract Day nextDay();
    
35. }
    

复制代码

其实枚举本质上就是一个抽象类，并且实例固定，构造函数固定，没法重新创建实例对象
建议你看下张孝祥老师关于java加强中枚举类的介绍 你就会明白了