1. public class EnumDemo {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 TrafficLamp red=TrafficLamp.Red;
   
5.                 System.out.println(red.NextLamp());
   
6.                 System.out.println("this time is "+red.Time);
   
7.         }
   
8. 
   
9.          public enum TrafficLamp{
   
10.                  Red(30){
    
11.                         public TrafficLamp NextLamp() {                                 
    
12.                                 return GREEN;
    
13.                         }                         
    
14.                  },
    
15.                  GREEN(45){
    
16.                         public TrafficLamp NextLamp() {
    
17.                         return YELLOW;
    
18.                         }                         
    
19.                  },
    
20.                  YELLOW(5){
    
21.                         public TrafficLamp NextLamp() {
    
22.                                 return Red;
    
23.                         }                         
    
24.                  };
    
25.                  //抽象方法
    
26.                  public abstract TrafficLamp NextLamp();
    
27.                  private int Time;
    
28.                   
    
29.                  //枚举的有参构造函数
    
30.                  private TrafficLamp(int time) {
    
31.                         this.Time=time;                       
    
32.                 }
    
33.          }
    
34. }

复制代码

是为了让每个子类单独实现该抽象方法

↑↓ME→← 发表于 2014-2-5 17:54
是为了让每个子类单独实现该抽象方法

枚举类不写抽象方法
子类元素里单独都写个方法不行吗

jiangyutc 发表于 2014-2-5 18:05
枚举类不写抽象方法
子类元素里单独都写个方法不行吗

枚举里面。每个元素都是一个对象，对象可能有抽下个方法吗？

黑马19我最牛 发表于 2014-2-5 19:56
枚举里面。每个元素都是一个对象，对象可能有抽下个方法吗？

我的意思是这个程序里面为什么一定要有抽象方法？
没有就不行吗？比如直接到元素里面创建这个一个方法

楼主的意思就是为什么非要定义一个抽象方法，然后再在枚举类中的每个实例对象中再去实现它对吧。
首先，没有也行，但是代码就不能这样写了，你必须单独定义方法来操作红绿灯变换的这些数据，代码如下：

1. public class EnumDemo {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.          public static void main(String[] args) {
   
7.          TrafficLamp red=TrafficLamp.Red;
   
8.          System.out.println(red.NextLamp());
   
9.          System.out.println("this time is "+red.Time);
   
10. }
    
11.          public enum TrafficLamp{
    
12.          Red(30){
    
13. //                public TrafficLamp NextLamp() {                                 
    
14. //                return GREEN;
    
15. //                }
    
16.          },
    
17.          GREEN(45){
    
18. //                public TrafficLamp NextLamp() {
    
19. //                return YELLOW;
    
20. //                }                        
    
21.          },
    
22.          YELLOW(5){
    
23. //                public TrafficLamp NextLamp() {
    
24. //                return Red;
    
25. //                }                        
    
26.          };
    
27.          //抽象方法
    
28.          //public abstract TrafficLamp NextLamp();
    
29.          //单独定义方法操作这些数据
    
30.          public TrafficLamp NextLamp() {                                 
    
31.              if (this==Red) {
    
32.                                 return GREEN;
    
33.                          }else if(this==GREEN){
    
34.                                  return YELLOW;
    
35.                          } else{
    
36.                                  return Red;
    
37.                          }
    
38.          }
    
39.          private int Time;
    
40.          
    
41.          //枚举的有参构造函数
    
42.          private TrafficLamp(int time) {
    
43.                 this.Time=time;                        
    
44.         }
    
45. }     
    
46. }

复制代码

然后就该说为什么要用抽象方法，像你的源程序中那样，定义一个抽象方法nextLamp()，然后让枚举类中的每个实例对象通过内部类实现它，这样会方便了很多，一是方便了调用nextLamp()方法，二是在枚举类中定义抽象方法以强制使每个实例对象都要实现这个方法，让程序符合实际情况。

陪你等日出 发表于 2014-2-7 01:20
楼主的意思就是为什么非要定义一个抽象方法，然后再在枚举类中的每个实例对象中再去实现它对吧。
首先，没 ...

多谢你懂我的意思，呵呵
但是我还是不明白，转换灯颜色的方法不是在元素里面有吗，
为什么非要在枚举类里面写呢？
red.NextLamp(); 这不就是调用元素里面的方法吗？
就是不要下面这段代码，和抽象方法为什么不行？可能是我基础学的不好，教教我呗
public TrafficLamp NextLamp() {                                 
             if (this==Red) {
                                return GREEN;
                         }else if(this==GREEN){
                                 return YELLOW;
                         } else{
                                 return Red;
                         }

不要这些方法咋调用?貌似会报方法没有定义的错误吧，这个方法是TrafficLamp类的内部类里面的方法，你用red.NextLamp()怎么能调用到啊.

1. public class EnumDemo {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 TrafficLamp red=TrafficLamp.Red;
   
5.                 System.out.println(red.NextLamp());
   
6.                 System.out.println("this time is "+red.Time);
   
7.         }
   
8. 
   
9.          public enum TrafficLamp{
   
10.                  Red(30){
    
11.                         public TrafficLamp NextLamp() {                                 
    
12.                                 return GREEN;
    
13.                         }                        
    
14.                  },
    
15.                  GREEN(45){
    
16.                         public TrafficLamp NextLamp() {
    
17.                         return YELLOW;
    
18.                         }                        
    
19.                  },
    
20.                  YELLOW(5){
    
21.                         public TrafficLamp NextLamp() {
    
22.                                 return Red;
    
23.                         }                        
    
24.                  };
    
25.                  //抽象方法
    
26.                  public abstract TrafficLamp NextLamp();
    
27.                  private int Time;
    
28.                   
    
29.                  //枚举的有参构造函数
    
30.                  private TrafficLamp(int time) {
    
31.                         this.Time=time;                        
    
32.                 }
    
33.          }
    
34. }

复制代码

枚举中加入，抽象方法，是让子类，必须写下该方法的实现。

作为抽象方法就是，以为着，该方法是，所有子类的抽象。所有子类向上抽取后，共有的该方法，增加了程序的扩展性，和严谨性~！！！！

希望对你有用》》》》》》怒进29期。

陪你等日出 发表于 2014-2-8 20:35
不要这些方法咋调用?貌似会报方法没有定义的错误吧，这个方法是TrafficLamp类的内部类里面的方法，你用red. ...

red.NextLamp()
的意思不就是调用red元素里面的NextLamp()方法吗？？？
不是说元素可以看作是子类吗，NextLamp()是在元素里面定义的方法啊，为什么不能这么调用？
我知道编译不通过，但是我想知道为什么不能通过

枚举类中每个元素表示是这个枚举类的一个实例对象.
枚举类没有定义NextLamp()这个方法的话,它的对象又怎么会有这个方法呢?所以肯定编译不会通过.