关于枚举的基本使用方法，我能理解。大家都知道枚举就是一个特殊的类 ，他和普通类一样，都可以实现一个或多个接口，同样可以包含抽象方法。
关于枚举实现接口或包含抽象方法，非常模糊。希望那问大神能详细的帮我解答一下。
比如枚举实现接口，肯定会实现接口中的所有方法。怎么让枚举中的不同对象，调用同一个方法出现不同的结果？
关于包含抽象方法，这个一点都不明白，不知道怎么去重写这个抽象方法？

public class EnumTest02 {

        /**
         * @param args
         */
        public static void main(String[] args) {
                Person p=Person.one;
                p.lie();
                p.rice();
        }
       
        interface  sleep{
                public void lie();
        }
        interface eat{
                public void rice();
        }
       
        public enum Person implements sleep,eat{
                one,two,three;
                private Person(){}
                public void lie(){
                        System.out.println("躺着睡");
                }
               
                public void rice(){
                        System.out.println("吃饭");
                }
               
        }

}

希望这代码能够解决你的问题。

楼主，你好！

如果您的问题解决了，请把您问题的未解决更改为已解决！

谢谢合作！

1. public interface Behaviour {  
   
2.     void print();  
   
3.     String getInfo();  
   
4. }  
   
5. public enum Color implements Behaviour{  
   
6.     RED("红色", 1), GREEN("绿色", 2),YELLO("黄色", 3);  
   
7.     // 成员变量  
   
8.     private String name;  
   
9.     private int index;  
   
10.     // 构造方法  
    
11.     private Color(String name, int index) {  
    
12.         this.name = name;  
    
13.         this.index = index;  
    
14.     }  
    
15. //接口方法  
    
16.     @Override  
    
17.     public String getInfo() {  
    
18.         return this.name;  
    
19.     }  
    
20.     //接口方法  
    
21.     @Override  
    
22.     public void print() {  
    
23.         System.out.println(this.index+":"+this.name);  
    
24.     }  
    
25. }  

复制代码

希望这个能帮的上你

实现带有抽象、构造方法的枚举：

public enum TrafficLamp{
    RED(30){
        public TrafficLamp nextLamp(){
           return GREEN;
        }
    },
    GREEN(40){
        public TrafficLamp nextLamp(){
           return YELLOW;
        }
    },
    YELLOW(5){
        public TrafficLamp nextLamp(){
           return RED;
        }
    };
    public abstract TrafficLamp nextLamp();
    private int time;
    private TrafficLamp(int time){this.time =time;}
}
在这个例子中，枚举TrafficLamp的三个成员RED,GREEN,YELLOW先调用TrafficLamp的带有int类型参数的构造方法创建，再实现枚举中的抽象方法nextLamp（），RED,GREEN,YELLOW调用同一个nextLamp()方法，分别返回的是自己的下一个灯，即调用同一个方法返回不同的结果，是一个比较复杂的枚举。

1. //枚举一般定义方式，每一个元素都是枚举的实例对象。我理解为空参数空方法。
   
2. /*
   
3.    public enum Fruits{
   
4.         APPLE，PEACH，PEAR
   
5. }
   
6. */
   
7. /*如果需要在枚举中定义构造方法。方法或者抽象方法时。需要在最后一个元素后加；（分号）后面写对应的方法。不管是实现的接口，还是自己定义的抽象方法。包括构造方法。都在枚举的实例对象中实现。*/
   
8. public enum Fruits implements Runnable {
   
9.         APPLE(1){
   
10.                 public void run(){}
    
11.                 public  void show(){}
    
12.         },PEACH(2){
    
13.                 public void run(){}
    
14.                 public  void show(){}
    
15.         }
    
16.         ,PEAR(3){
    
17.                 public void run(){}
    
18.                 public  void show(){}
    
19.         };
    
20.         //定义构造方法必须为private
    
21.         private Fruits(int num){}
    
22.         //定义抽象方法
    
23.         public abstract void show();
    
24.         
    
25. }

复制代码

不知道你要的是什么效果，随便写了个。
接口：
public interface Test {
        public void prints();
}

实现类是张老师的交通灯那个灯类，我只把实现方法写一下：

@Override
        public void prints() {
                // TODO Auto-generated method stub
                System.out.println(this.name());
               
        }

调用prints方法就会打印出调用者的名字。貌似跟普通类差不多

实现接口部分， 你可以去JDK里面找一下枚举的values()方法。
---稍等一下，我去试试= =