/*
       老师讲过，枚举类也是一个类，只是表现方式不一样（关键字enum)。我们知道，如果一个类中有抽象方法，那么这个类一定要是抽象类。
但下面的代码中为什么枚举类中有抽象方法，而类名上又没有标名是抽象类，却没有报错？？
    */

           public enum TrafficLamp{
                RED(30){
                        @Override
                        public TrafficLamp nextLamp() {
                                return GREEN;
                        }
                },GREEN(45) {
                        @Override
                        public TrafficLamp nextLamp() {
                                return YELLOW;
                        }
                },YELLOW(5) {
                        @Override
                        public TrafficLamp nextLamp() {
                                return RED;
                        }
                };
               
                public abstract TrafficLamp nextLamp();                
                                 private int time;
               
                private TrafficLamp(int time){
                        this.time = time;
                }
        }
}

你想说的应该是枚举中有抽象方法，而类为什么不用抽象修饰了？abstract是抽象的修饰符。静态的是修饰符是static。
enum这个类本身就是一个抽象类，所以enum好比一个修饰符，你可以把他看着他本身就带了abstract修饰吧。

enum关键词就有了abstract的含义，因为enum类是不允许其他的类进行创建实例的，
抽象类中不一定包含抽象方法，但是包含抽象方法的类一定要被声明为抽象类。

翻译起来就是：枚举中可以用抽象方法，但是枚举中的每一个对象都分别实现抽象方法

举例子：枚举中可以用抽象方法，但是枚举中的每一个对象都分别实现抽象方法；而且枚举还可以实现接口，在实现接口的时候覆写接口的抽象方法就可以了。
public class Main{

       public static void main(String[] args) {

               TraLight r = TraLight.RED;

               TraLight t = r.Nextlight();

             System.out.println(t);

                System.out.println(r);

        }

}

//输出：

green color

RED RED RED

enum TraLight {

       RED ("red color"){//括号里是使用构造方法时传递的实参

              public TraLight Nextlight() {

                      return GREEN;

               }

                public String toString(){//再次重写toString方法。

                     return "RED RED RED";

               }

        },

        GREEN ("green color"){

               public TraLight Nextlight() {

                      return YELLOW;

              }

        },

        YELLOW ("yellow color"){

                public TraLight Nextlight() {

                        return RED;

               }

       };

        private TraLight(String s){//构造方法，必须是私有的，只能内部调用，当在外部使用TraLigh r = TraLighr.RED;时，内部会执行此构造方法，并传进相应的参数。

              this.s = s;

       }

        public String toString(){//重写toString方法

                return s;

        }

        public abstract TraLight Nextlight();//此为抽象方法，子类必须实现

        private String s;

}

//enum是特殊的class，实际上enum声明定义的类型就是一个类。 而这些类都是类库中Enum类的子类(java.lang.Enum<E>)。它们继承了这个Enum中的许多有用的方法。代码编译之后成了一个字节码文件：TraLight.class。

//下面是其字节码文件，可以看出来其本身就是一个抽象类。

Compiled from "TraLight.java"

abstract class TraLight extends java.lang.Enum{

   public static final TraLight RED;//TraLight类型

    public static final TraLight GREEN;

    public static final TraLight YELLOW;

    public static TraLight[] values();

   public static TraLight valueOf(java.lang.String);

    public java.lang.String toString();

    public abstract TraLight Nextlight();

   TraLight(java.lang.String, int, java.lang.String, TraLight$1);

   static {};

}

//枚举值RED\GREEN\YELLOW是枚举类TraLight的一个子类，所以必须实现其抽象方法。

枚举本身就是一个抽象类，因为枚举不能被别的类实例化