在枚举中能定义抽象方法吗？为什么？

enum很像特殊的class，实际上enum声明定义的类型就是一个类。 而这些类都是类库中Enum类的子类(java.lang.Enum<E>)。它们继承了这个Enum中的许多有用的方法。经过查看源码发现它将自己的构造函数也私有化了，它在创建对象时，调用的是父类方法中的Enum的受保护构造器创建一个枚举对象。

Enum
protected Enum(String name,
                int ordinal)单独的构造方法。程序员无法调用此构造方法。该构造方法用于由响应枚举类型声明的编译器发出的代码。

参数：
name - - 此枚举常量的名称，它是用来声明该常量的标识符。
ordinal - - 枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。

那么我们都知道被私有化的构造函数，说明这个类不能让外部通过new的方式来创建，所以这时候它是不能被实例化。也就是说不能abstract修饰。
还有一个问题就是当我们在枚举类中定义了一个抽象方法，我们是需要使用枚举值来实现这个方法，是因为枚举值它的实现是通过调用私有的构造方法，在底层创建了对象，而这时候的枚举值就相当于= new 枚举(),那么因为它里边带有抽象方法，在我们创建对象时，是需要去实现这个构造方法，所以这时候就相当于new 枚举（）{。。。。。。.//实现的过程}

enum Demo{
         RED {
                 @Override
                 void show () {
                         // TODO Auto-generated method stub
                        
                }
         },COL {
                 @Override
                 void show () {
                         // TODO Auto-generated method stub
                        
                }
         };
         abstract void show();
}

枚举中是可以定义抽象方法的
而且，被枚举的成员其实就是定义的枚举类型的一个实例。他们都被默认为final
例如：
enum EnumDemo {
        LEFT{
                public String show() //覆盖抽象方法
                        return "左";
                }
        },
        RIGHT{
                public String show(){
                        return "右";
                }
        };
        public abstract String show();
}

public class Test{
    public static void main(String[] args) {   
     System.out.println(EnumDemo.LEFT.show());
    }   
}

枚举类型可以跟普通的类一样实现一个接口，但是实现接口的时候要求枚举中的每一个对象都必须单独覆写好接口中的抽象方法

范例实现接口

定义一个接口

package com.qn.test1;

public interface Print{

public String getColor();
}  


定义一个类

package com.qn.test1;

public enum Color implements Print {

RED {
  public String getColor() {
   return "红色";
  }
},
BLUE {
  public String getColor() {
   return "蓝色";
  }
},
GREEN {
  public String getColor() {
   return "绿色";
  }
}

}

在test类中进行测试

package com.qn.test1;

public class Test1 {
      public static void main(String[] args) {
  for(Color c:Color.values()){
   System.out.print(c+"、");
  }
}
}


还可以直接在枚举中定义抽象方法，但是要求枚举中的每一个对象都分别实现抽象方法

定义一个枚举类

package com.qn.test1;

public enum Color{

RED {
  public String getColor() {
   return "红色";
  }
},
BLUE {
  public String getColor() {
   return "蓝色";
  }
},
GREEN {
  public String getColor() {
   return "绿色";
  }
};
public abstract String getColor();

}


在test类中进行测试

package com.qn.test1;

public class Test1 {
      public static void main(String[] args) {
  for(Color c:Color.values()){
   System.out.print(c+"、");
  }
}
}








package com.qn.test1;

public interface Print{

public String getColor();
}  


定义一个类

package com.qn.test1;

public enum Color implements Print {

RED {
  public String getColor() {
   return "红色";
  }
},
BLUE {
  public String getColor() {
   return "蓝色";
  }
},
GREEN {
  public String getColor() {
   return "绿色";
  }
}

}

在test类中进行测试

package com.qn.test1;

public class Test1 {
      public static void main(String[] args) {
  for(Color c:Color.values()){
   System.out.print(c+"、");
  }
}
}


还可以直接在枚举中定义抽象方法，但是要求枚举中的每一个对象都分别实现抽象方法

定义一个枚举类

package com.qn.test1;

public enum Color{

RED {
  public String getColor() {
   return "红色";
  }
},
BLUE {
  public String getColor() {
   return "蓝色";
  }
},
GREEN {
  public String getColor() {
   return "绿色";
  }
};
public abstract String getColor();

}


在test类中进行测试

package com.qn.test1;

public class Test1 {
      public static void main(String[] args) {
  for(Color c:Color.values()){
   System.out.print(c+"、");
  }
}
}

枚举类型可以跟普通的类一样实现一个接口，但是实现接口的时候要求枚举中的每一个对象都必须单独覆写好接口中的抽象方法

范例实现接口

定义一个接口

package com.qn.test1;

public interface Print{

public String getColor();
}  


定义一个类

package com.qn.test1;

public enum Color implements Print {

RED {
  public String getColor() {
   return "红色";
  }
},
BLUE {
  public String getColor() {
   return "蓝色";
  }
},
GREEN {
  public String getColor() {
   return "绿色";
  }
}

}

在test类中进行测试

package com.qn.test1;

public class Test1 {
      public static void main(String[] args) {
  for(Color c:Color.values()){
   System.out.print(c+"、");
  }
}
}


还可以直接在枚举中定义抽象方法，但是要求枚举中的每一个对象都分别实现抽象方法

定义一个枚举类

package com.qn.test1;

public enum Color{

RED {
  public String getColor() {
   return "红色";
  }
},
BLUE {
  public String getColor() {
   return "蓝色";
  }
},
GREEN {
  public String getColor() {
   return "绿色";
  }
};
public abstract String getColor();

}


在test类中进行测试

package com.qn.test1;

public class Test1 {
      public static void main(String[] args) {
  for(Color c:Color.values()){
   System.out.print(c+"、");
  }
}
}








package com.qn.test1;

public interface Print{

public String getColor();
}  


定义一个类

package com.qn.test1;

public enum Color implements Print {

RED {
  public String getColor() {
   return "红色";
  }
},
BLUE {
  public String getColor() {
   return "蓝色";
  }
},
GREEN {
  public String getColor() {
   return "绿色";
  }
}

}

在test类中进行测试

package com.qn.test1;

public class Test1 {
      public static void main(String[] args) {
  for(Color c:Color.values()){
   System.out.print(c+"、");
  }
}
}


还可以直接在枚举中定义抽象方法，但是要求枚举中的每一个对象都分别实现抽象方法

定义一个枚举类

package com.qn.test1;

public enum Color{

RED {
  public String getColor() {
   return "红色";
  }
},
BLUE {
  public String getColor() {
   return "蓝色";
  }
},
GREEN {
  public String getColor() {
   return "绿色";
  }
};
public abstract String getColor();

}


在test类中进行测试

package com.qn.test1;

public class Test1 {
      public static void main(String[] args) {
  for(Color c:Color.values()){
   System.out.print(c+"、");
  }
}
}