java枚举使用 总结

补充几点：

1.枚举对象是可以用 == 比较。

2.

TestEnum3反编译结果：

F:\tree\Test\src\test>javap TestEnum3*
Compiled from "TestEnum3.java"
final class test.TestEnum3$1 extends test.TestEnum3 {
  test.TestEnum3$1(java.lang.String, int);
  void discription();
}
Compiled from "TestEnum3.java"
final class test.TestEnum3$2 extends test.TestEnum3 {
  test.TestEnum3$2(java.lang.String, int);
  void discription();
}
Compiled from "TestEnum3.java"
final class test.TestEnum3$3 extends test.TestEnum3 {
  test.TestEnum3$3(java.lang.String, int);
  void discription();
}
Compiled from "TestEnum3.java"
public abstract class test.TestEnum3 extends java.lang.Enum<test.TestEnum3> {
  public static final test.TestEnum3 GREEN;
  public static final test.TestEnum3 RED;
  public static final test.TestEnum3 YELLOW;
  public static test.TestEnum3[] values();
  public static test.TestEnum3 valueOf(java.lang.String);
  abstract void discription();
  public static void main(java.lang.String[]);
  test.TestEnum3(java.lang.String, int, test.TestEnum3$1);
  static {};
}

TestEnum5反编译结果：

public final class test.TestEnum5 extends java.lang.Enum<test.TestEnum5> {
  public static final test.TestEnum5 RED;
  public static final test.TestEnum5 GREEN;
  public static final test.TestEnum5 YELLOW;
  public static test.TestEnum5[] values();
  public static test.TestEnum5 valueOf(java.lang.String);
  public java.lang.String getColor();
  public int getIndex();
  public java.lang.String toString();
  public static java.lang.String getInstance(int);
  public static void main(java.lang.String[]);
  static {};
}

 package test;

 enum Colors {
     RED, YELLOW, WHITE, GREEN
 }

 /**
  *
  * @Function:TestEnum
  * @Description: 枚举做常量
  * @author
  * @date :2018/04/10上午11:00:09
  *
  */
 public class TestEnum {

     public static void main(String[] args) {
         for (Colors string : Colors.values()) {
             System.out.println("color:" + string);
         }
         System.out.println("====================");
         for (Colors string : Colors.values()) {
             System.out.println(string + " ordinal " + string.ordinal());
         }
     }
 }
 /*
  * color:RED
  * color:YELLOW
  * color:WHITE
  * color:GREEN
  * ====================
  * RED ordinal 0
  * YELLOW ordinal 1
  * WHITE ordinal 2
  * GREEN ordinal 3
  */

 package test;

 enum Color {
     GREEN, RED, YELLOW, White
 }

 /**
  *
  * @Function:TestEnum
  * @Description: 枚举作用于switch
  * @author
  * @date :2018/04/10上午11:00:09
  *
  */
 public class TestEnum1 {
     Color color = Color.White;

     public static void main(String[] args) {

         TestEnum1 testEnum = new TestEnum1();
         System.out.println(testEnum.change());

     }

     public Color change() {
         switch (color) {

         case GREEN:
             color = Color.GREEN;
             break;
         case RED:
             color = Color.RED;
             break;
         case YELLOW:
             color = Color.YELLOW;
             break;
         case White:
             color = Color.White;
             break;
         }
         return color;
     }
 }
 /*
  * White
  */

 package test;

 /**
  *
  * @Function:TestEnum
  * @Description: 枚举添加方法
  * @author
  * @date :2018/04/10上午11:00:09
  *
  */
 public enum TestEnum2 {
     RED("红色", 1), YELLOW("黄色", 2), WHITE("白色", 3);

     private String color;
     private int index;

     // 私有构造方法
     private TestEnum2(String color, int index) {
         this.color = color;
         this.index = index;
     }

     // 通过index获取颜色的静态方法
     public static String getColor(int index) {
         for (TestEnum2 colorObj : TestEnum2.values()) {
             if (colorObj.getIndex() == index) {
                 return colorObj.getColor();
             }
         }
         return null;
     }

     public String getColor() {
         return color;
     }

     public int getIndex() {
         return index;
     }

     public static void main(String[] args) {
         System.out.println(getColor(2));
     }
 }
 /*
  * 黄色
  */

 package test;

 /**
  *
  * @Function:TestEnum3
  * @Description:枚举多态性，添加抽象方法
  * @author
  * @date :2018/04/10上午11:04:27 编译javac **.java ，反编译 javap **
  *       反编译后发现，"枚举常量"继承了TestEnum3重写了抽象方法,此类java.lang.Enum抽象类子类，反编译后此类为抽象类
  */
 public enum TestEnum3 {
     GREEN {
         void discription() {
             System.out.println("绿灯行！");
         }
     },
     RED {
         void discription() {
             System.out.println("红灯停！");
         }
     },
     YELLOW {
         void discription() {
             System.out.println("黄灯等一等！");
         }
     };
     abstract void discription();

     public static void main(String[] args) {
         for (TestEnum3 s : TestEnum3.values()) {
             s.discription();
         }
     }
 }
 /*
  * 绿灯行！
  * 红灯停！
  * 黄灯等一等！
  */

 package test;

 /**
  *
  * @Function:TestEnum4
  * @Description: 利用构造器为实例添加描述
  * @author
  * @date :2018/04/10下午12:06:54
  *
  */
 public enum TestEnum4 {
     RED("红色"), GREEN("绿色"), YELLOW("黄色"); //实为类对象的实例引用

     public String colorFlag;

     // 我的理解是，枚举常量内的参数(描述)需要跟这个私有的构造器参数一致
     private TestEnum4(String flag) {
         this.colorFlag = flag;
     }

     public String getColorFlag() {
         return colorFlag;
     }

     public static void main(String[] args) {
         for (TestEnum4 s : TestEnum4.values()) {
             System.out.println(s.getColorFlag());
         }
     }

 }
 /*
  * 红色
  * 绿色
  * 黄色
  */

 package test;

 /**
  *
  * @Function:TestEnum5
  * @Description: 覆盖枚举的方法
  * @author
  * @date :2018/04/10下午12:06:54 ================================在本类不能实例化(不知原因)
  */
 public enum TestEnum5 {
     RED("红色", 1), GREEN("绿色", 2), YELLOW("黄色", 3);

     private String color;
     private int index;

     // 我的理解是，枚举常量内的参数(描述)需要跟这个私有的构造器参数一致
     private TestEnum5(String color, int index) {
         this.color = color;
         this.index = index;
     }

     public String getColor() {
         return color;
     }

     public int getIndex() {
         return index;
     }

     @Override
     public String toString() {
         return this.index + " _color:" + this.color;
     }

     public static String getInstance(int index) {
         for (TestEnum5 s : TestEnum5.values()) {
             if (s.getIndex() == index) {
                 // 入果去掉重写toString方法，则返回RED
                 return s.toString();
             }
         }
         return null;
     }

     public static void main(String[] args) {
         System.out.println(getInstance(2));
     }
 }
 /*
  * 2 _color:绿色
  */

 package test;

 interface Color6 {
     void print();

     String getColor();
 }

 /**
  *
  * @Function:TestEnum6
  * @Description: 枚举实现接口
  * @author
  * @date :2018/04/10下午1:44:46
  *
  */
 public enum TestEnum6 implements Color6 {
     RED("红色", 1), GREEN("绿色", 2), YELLOW("黄色", 3);

     private String color;
     private int index;

     private TestEnum6(String color, int index) {
         this.color = color;
         this.index = index;
     }

     @Override
     public void print() {
         //补充：this.name 可以返回此枚举常量名称
         System.out.println(this.index + " color:" + this.color);
     }

     @Override
     public String getColor() {
         return this.color;
     }

     public static void main(String[] args) {
         for (TestEnum6 t : TestEnum6.values()) {
             t.print();
         }
     }
 }
 /*
  *  1 color:红色
  *    2 color:绿色
  *    3 color:黄色
 */

 package test;

 interface Color7 {

     enum colors1 implements Color7 {
         YELLOW_FRUIT, GREEN_FRUIT, RED_FRUIT
     }

     enum colors2 implements Color7 {
         YELLOW, GREEN, RED
     }
 }

 /**
  *
  * @Function:TestEnum6
  * @Description: 使用接口组织枚举
  * @author
  * @date :2018/04/10下午1:44:46
  *
  */
 public class TestEnum7 implements Color7 {
     public static void testImplInstance() {
         for (Color7.colors1 c1 : Color7.colors1.values()) {
             System.out.println(c1.name());
         }
         System.out.println("==================");
         for (Color7 c2 : Color7.colors2.values()) {
             System.out.println(c2);
         }
         System.out.println("==================");
         // 搞个实现接口，来组织枚举，简单讲，就是分类吧。如果大量使用枚举的话，这么干，在写代码的时候，就很方便调用啦。
         // 还有就是个“多态”的功能吧，
         Color7 color = Color7.colors2.YELLOW;
         System.out.println(color);
     }

     public static void main(String[] args) {
         testImplInstance();
     }
 }
 /*
  *    YELLOW_FRUIT
  *    GREEN_FRUIT
  *    RED_FRUIT
  *    ==================
  *    YELLOW
  *    GREEN
  *    RED
  *    ==================
  *    YELLOW
  */