public class EnumTest {
public static void main(String[] args)
{
  TraLight r =TraLight.RED;
  TraLight t= r.Nextlight();
  System.out.println(t);
  
}
}
  enum TraLight
{
  RED
  {
   public TraLight Nextlight()
   {
    return GREEN;
   }
  },
  GREEN
  {
   public TraLight Nextlight()
   {
    return YELLOW;
   }   
  },
  YELLOW
  {
   public TraLight Nextlight()
   {
    return RED;
   }
  };
  public abstract TraLight Nextlight();
}
/*
这个程序可以正常运行，我已经实验过了。但我不知道TraLight里面明显有abstract抽象方法，而TraLight却没有抽象关键字abstract，请高手指教，谢谢！
*/

枚举中可以用抽象方法，但是枚举中的每一个对象都分别实现抽象方法；而且枚举还可以实现接口，在实现接口的时候覆写接口的抽象方法就可以了。就你代码我修改了一下，怎样实现接口

public interface interfa {
                public abstract TraLight Nextlight();
        }

        enum TraLight implements interfa{
                RED {
                        public TraLight Nextlight() {
                                return GREEN;
                        }
                },
                GREEN {
                        public TraLight Nextlight() {
                                return YELLOW;
                        }
                },
                YELLOW {
                        public TraLight Nextlight() {
                                return RED;
                        }
                };
               

        }

        public static void main(String[] args) {
                TraLight r = TraLight.RED;
                TraLight t = r.Nextlight();
                System.out.println(t);

        }

enum这个类本身就是一个抽象类，所以可以不用abstract 修饰。

1. public class Main{
   
2.         public static void main(String[] args) {
   
3.                 TraLight r = TraLight.RED;
   
4.                 TraLight t = r.Nextlight();
   
5.                 System.out.println(t);
   
6.                 System.out.println(r);
   
7.         }
   
8. }
   
9. //输出：
   
10. green color
    
11. RED RED RED
    
12. enum TraLight {
    
13.         RED ("red color"){//括号里是使用构造方法时传递的实参
    
14.                 public TraLight Nextlight() {
    
15.                         return GREEN;
    
16.                 }
    
17.                 public String toString(){//再次重写toString方法。
    
18.                         return "RED RED RED";
    
19.                 }
    
20.         },
    
21.         GREEN ("green color"){
    
22.                 public TraLight Nextlight() {
    
23.                         return YELLOW;
    
24.                 }
    
25.         },
    
26.         YELLOW ("yellow color"){
    
27.                 public TraLight Nextlight() {
    
28.                         return RED;
    
29.                 }
    
30.         };
    
31.         private TraLight(String s){//构造方法，必须是私有的，只能内部调用，当在外部使用TraLigh r = TraLighr.RED;时，内部会执行此构造方法，并传进相应的参数。
    
32.                 this.s = s;
    
33.         }
    
34.         public String toString(){//重写toString方法
    
35.                 return s;
    
36.         }
    
37.         public abstract TraLight Nextlight();//此为抽象方法，子类必须实现
    
38.         private String s;
    
39. }
    
40. //enum是特殊的class，实际上enum声明定义的类型就是一个类。 而这些类都是类库中Enum类的子类(java.lang.Enum<E>)。它们继承了这个Enum中的许多有用的方法。代码编译之后成了一个字节码文件：TraLight.class。
    
41. //下面是其字节码文件，可以看出来其本身就是一个抽象类。
    
42. Compiled from "TraLight.java"
    
43. abstract class TraLight extends java.lang.Enum{
    
44.     public static final TraLight RED;//TraLight类型
    
45.     public static final TraLight GREEN;
    
46.     public static final TraLight YELLOW;
    
47.     public static TraLight[] values();
    
48.     public static TraLight valueOf(java.lang.String);
    
49.     public java.lang.String toString();
    
50.     public abstract TraLight Nextlight();
    
51.     TraLight(java.lang.String, int, java.lang.String, TraLight$1);
    
52.     static {};
    
53. }
    
54. //枚举值RED\GREEN\YELLOW是枚举类TraLight的一个子类，所以必须实现其抽象方法。

复制代码

郑传庆 发表于 2012-6-10 19:11
枚举中可以用抽象方法，但是枚举中的每一个对象都分别实现抽象方法；而且枚举还可以实现接口，在实现接口的 ...

谢谢你，我已经明白了。

我觉得你的代码写的真有层次感，羡慕。
另外我觉得用抽象方法比你有接口更简便和节省空间，你是怎样认为的，看你这么会用接口，我想证取下你的意见。

晏文根 发表于 2012-6-10 19:30
谢谢你，我已经明白了。

我觉得你的代码写的真有层次感，羡慕。

我这样理解了,java只能提供的接口是用来弥补java单继承的缺陷，也就说用接口来实现类与类之间多重继承的功能的,方便程序使用；抽象类是据有一个或多个抽象方法的类，必须声明为抽象类。抽象类的特点是:不能创建实例。至于你说哪个更简便和节省空间，我也无法具体回答，因为在实际开发中就不好确定了。 建议LZ可以到网上找资料看看

郑传庆 发表于 2012-6-10 19:55
我这样理解了,java只能提供的接口是用来弥补java单继承的缺陷，也就说用接口来实现类与类之间多重继承的 ...

知道了，谢谢！