如何实现带抽象方法的枚举，
表示下面的代码没看懂

1. public enum TrafficLamp{
   
2.                 Red(30){//red是一个元素，它是由trafficLamp子类来实现的
   
3.                         public TrafficLamp nextLamp(){
   
4.                                 return Green;
   
5.                         }
   
6.                        
   
7.                 },
   
8.                 Green(45){
   
9.                         public TrafficLamp nextLamp(){
   
10.                                 return Yellow;
    
11.                         }
    
12.                 },
    
13.                 Yellow(5){
    
14.                         public TrafficLamp nextLamp(){
    
15.                                 return Green;
    
16.                         }
    
17.                 };
    
18.                 public abstract TrafficLamp nextLamp();
    
19.                        
    
20.                 private int time;
    
21.                 private TrafficLamp(int time){
    
22.                         this.time=time;
    
23.                 }
    
24.                
    
25.         }

复制代码

把枚举里面的每一个枚举常量，当做一个对象来看待。枚举体里有抽象方法，理解我为一个对象继承了一个抽象类，那它就要实现自己的抽象方法。

1. public abstract class TrafficLampABS {
   
2.         public abstract  String nextLamp();
   
3. }
   
4. 
   
5. 
   
6. class  Red extends TrafficLampABS{
   
7. 
   
8.         @Override
   
9.         public String nextLamp() {
   
10.                 // TODO Auto-generated method stub
    
11.                 return "Green";
    
12.         }
    
13.        
    
14. }

复制代码

这样理解，应该清楚了吧。

如果一个类中有抽象方法那么这个类也必须要做成抽象的。抽象类不能直接new他的实例。我们只能new它的子类对象。在new它的子类对象的时候。必须要去实现里面的抽象方法。

两个地方希望能帮到你，如下代码所示。

1. public enum TrafficLamp{
   
2.             Red(30){//red是一个元素，它是由trafficLamp子类来实现的
   
3.                     //1.你上面这句话有问题，Red其实就是TrafficLamp的一个实例对象。
   
4.                             public TrafficLamp nextLamp(){
   
5.                             return Green;
   
6.                     }
   
7.                    
   
8.             },
   
9.             Green(45){
   
10.                     public TrafficLamp nextLamp(){
    
11.                             return Yellow;
    
12.                     }
    
13.             },
    
14.             Yellow(5){
    
15.                     public TrafficLamp nextLamp(){
    
16.                             return Green;
    
17.                     }
    
18.             };
    
19.             //2.这里定义了抽象方法nextLamp()，每个元素(即每个实例对象)中就必须复写这个抽象方法咯
    
20.             public abstract TrafficLamp nextLamp();      
    
21.             private int time;
    
22.             private TrafficLamp(int time){
    
23.                     this.time=time;
    
24.             }
    
25.             
    
26.         }

复制代码