枚举

枚举

1.枚举的用法及使用场景

在实际编程中，往往存在着这样的“数据集”，它们的数值在程序中是稳定的，而且“数据集”中的元素是有限的。

例如星期一到星期日七个数据元素组成了一周的“数据集”，春夏秋冬四个数据元素组成了四季的“数据集”。

在java中如何更好的使用这些“数据集”呢？因此枚举便派上了用场，以下代码详细介绍了枚举的用法。

package basicExercises ;

public class test {
    // 普通枚举
    public enum ColorEnum {
        red ,  green ,  yellow ,  blue ;
    }
    // 枚举像普通的类一样可以添加属性和方法，可以为它添加静态和非静态的属性或方法
    public enum SeasonEnum {
        // 注：枚举写在最前面，否则编译出错
        spring ,  summer ,  autumn ,  winter ;
        private final static String  position =  "test" ;
        public static SeasonEnum  getSeason() {
            if ( "test".equals( position)) // 编译后是 "test".equals(test)
                return  spring ;
            else
                return  winter ;
        }
    }
    // 性别 : 实现带有构造器的枚举
    public enum Gender{
        // 通过括号赋值 , 而且必须带有一个参构造器和一个属性跟方法，否则编译出错
        // 赋值必须都赋值或都不赋值，不能一部分赋值一部分不赋值；如果不赋值则不能写构造器，赋值编译也出错
        MAN( "MAN") ,  WOMEN( "WOMEN") ;
        private final String  value ;
        // 构造器默认也只能是 private,  从而保证构造函数只能在内部使用
        Gender(String value) {
            this. value = value ;
        }
        public String  getValue() {
            return  value ;
        }
    }
    // 订单状态 : 实现带有抽象方法的枚举
    public enum OrderState {
        CANCEL { public String  getName(){ return  " 已取消 " ;}} ,
        WAITCONFIRM { public String  getName(){ return  " 待审核 " ;}} ,
        WAITPAYMENT { public String  getName(){ return  " 等待付款 " ;}} ,
        ADMEASUREPRODUCT { public String  getName(){ return  " 正在配货 " ;}} ,
        WAITDELIVER { public String  getName(){ return  " 等待发货 " ;}} ,
        DELIVERED { public String  getName(){ return  " 已发货 " ;}} ,
        RECEIVED { public String  getName(){ return  " 已收货 " ;}} ;
        public abstract String  getName() ;
    }
    public static void  main(String[] args) {
        // 枚举是一种类型，用于定义变量，以限制变量的赋值；赋值时通过 “ 枚举名 . 值 ” 取得枚举中的值
        ColorEnum colorEnum = ColorEnum. blue ;
        switch (colorEnum) {
            case  red:
                System. out.println( "color is red") ;
                break;
            case  green:
                System. out.println( "color is green") ;
                break;
            case  yellow:
                System. out.println( "color is yellow") ;
                break;
            case  blue:
                System. out.println( "color is blue") ;
                break;
        }
        // 遍历枚举
        System. out.println( " 遍历 ColorEnum 枚举中的值 ") ;
        for(ColorEnum color : ColorEnum. values()){
            System. out.println(color) ;
        }
        // 获取枚举的个数
        System. out.println( "ColorEnum 枚举中的值有 "+ColorEnum. values(). length+ " 个 ") ;
        // 获取枚举的索引位置，默认从 0 开始
        System. out.println(ColorEnum. red.ordinal()) ; //0
        System. out.println(ColorEnum. green.ordinal()) ; //1
        System. out.println(ColorEnum. yellow.ordinal()) ; //2
        System. out.println(ColorEnum. blue.ordinal()) ; //3

        // 枚举默认实现了 java.lang.Comparable 接口
        System. out.println(ColorEnum. red.compareTo(ColorEnum. green)) ; //-1
        //--------------------------
        System. out.println( "===========") ;
        System. err.println( " 季节为 " + SeasonEnum. getSeason()) ;
        //--------------
        System. out.println( "===========") ;
        for(Gender gender : Gender. values()){
            System. out.println(gender. value) ;
        }
        //--------------
        System. out.println( "===========") ;
        for(OrderState order : OrderState. values()){
            System. out.println(order.getName()) ;
        }
    }
}

//运行结果

color is blue

季节为spring

遍历ColorEnum枚举中的值

red

green

yellow

blue

ColorEnum枚举中的值有4个

0

1

2

3

-1

===========

===========

MAN

WOMEN

===========

已取消

待审核

等待付款

正在配货

等待发货

已发货

已收货

2.枚举用法举例

用法一：常量

1. public enum Color {  
2.   RED, GREEN, BLANK, YELLOW  
3. }  

用法二：switch

1. enum Signal {  
2.     GREEN, YELLOW, RED  
3. }  
4. public class TrafficLight {  
5.     Signal color = Signal.RED;  
6.     public void change() {  
7.         switch (color) {  
8.         case RED:  
9.             color = Signal.GREEN;  
10.             break;  
11.         case YELLOW:  
12.             color = Signal.RED;  
13.             break;  
14.         case GREEN:  
15.             color = Signal.YELLOW;  
16.             break;  
17.         }  
18.     }  
19. }  

用法三：向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且  Java 要求必须先定义  enum 实例。

1. public enum Color {  
2.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
3.     // 成员变量  
4.     private String name;  
5.     private int index;  
6.     // 构造方法  
7.     private Color(String name, int index) {  
8.         this.name = name;  
9.         this.index = index;  
10.     }  
11.     // 普通方法  
12.     public static String getName(int index) {  
13.         for (Color c : Color.values()) {  
14.             if (c.getIndex() == index) {  
15.                 return c.name;  
16.             }  
17.         }  
18.         return null;  
19.     }  
20.     // get set 方法  
21.     public String getName() {  
22.         return name;  
23.     }  
24.     public void setName(String name) {  
25.         this.name = name;  
26.     }  
27.     public int getIndex() {  
28.         return index;  
29.     }  
30.     public void setIndex(int index) {  
31.         this.index = index;  
32.     }  
33. }  

用法四：覆盖枚举的方法

1. public enum Color {  
2.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
3.     // 成员变量  
4.     private String name;  
5.     private int index;  
6.     // 构造方法  
7.     private Color(String name, int index) {  
8.         this.name = name;  
9.         this.index = index;  
10.     }  
11.     //覆盖方法  
12.     @Override  
13.     public String toString() {  
14.         return this.index+"_"+this.name;  
15.     }  
16. }  

 

用法五：实现接口

所有的枚举都继承自java.lang.Enum类。由于 Java 不支持多继承，所以枚举对象不能再继承其他类。

1. public interface Behaviour {  
2.     void print();  
3.     String getInfo();  
4. }  
5. public enum Color implements Behaviour{  
6.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
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. }  

用法六：使用接口组织枚举

Java代码 

1. public interface Food {  
2.     enum Coffee implements Food{  
3.         BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
4.     }  
5.     enum Dessert implements Food{  
6.         FRUIT, CAKE, GELATO  
7.     }  
8. }  

 

用法七：关于枚举集合的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。

EnumSet保证集合中的元素不重复；

EnumMap中的 key是enum类型，而value则可以是任意类型。

private  static  void  testEnumMap() {

        //  1.演示定义EnumMap对象，EnumMap对象的构造函数需要参数传入,默认是key的类的类型

        EnumMap<Light, String> currEnumMap =  new EnumMap<Light, String> (Light. class);

        currEnumMap.put(Light.RED, "红灯" );

        currEnumMap.put(Light.GREEN, "绿灯" );

        currEnumMap.put(Light.YELLOW, "黄灯" );

        //  2.遍历对象

        for  (Light aLight : Light.values()) {

            System.out.println("[key=" + aLight.name() + ",value=" + currEnumMap.get(aLight) + "]");

         }

    }

3.分析总结：

enum 的语法结构尽管和 class 的语法不一样，但是经过编译器编译之后产生的是一个class文件。

该class文件经过反编译可以看到实际上是生成了一个类，该类继承了java.lang.Enum<E>。

EnumTest 经过反编译(javap com.hmw.test.EnumTest 命令)之后得到的内容如下：

public  class  com.hmw.test.EnumTest extends  java.lang.Enum{      public  static  final  com.hmw.test.EnumTest MON;      public  static  final  com.hmw.test.EnumTest TUE;      public  static  final  com.hmw.test.EnumTest WED;      public  static  final  com.hmw.test.EnumTest THU;      public  static  final  com.hmw.test.EnumTest FRI;      public  static  final  com.hmw.test.EnumTest SAT;      public  static  final  com.hmw.test.EnumTest SUN;      static  {};      public  int  getValue();      public  boolean  isRest();      public  static  com.hmw.test.EnumTest[] values();      public  static  com.hmw.test.EnumTest valueOf(java.lang.String);      com.hmw.test.EnumTest(java.lang.String, int , int , com.hmw.test.EnumTest); }

所以，实际上 enum 就是一个 class，只不过 java 编译器帮我们做了语法的解析和编译而已。

可以把 enum 看成是一个普通的 class，它们都可以定义一些属性和方法，不同之处是：enum 不能使用 extends 关键字继承其他类，因为 enum 已经继承了 java.lang.Enum（java是单一继承）。