java枚举类型enum的使用



同事提到我们为什么java 中定义的常量值不采用enmu 枚举类型，而采用public final static 类型来定义呢？以前我们都是采用这种方式定义的，很少采用enum 定义，所以也都没有注意过，面对突入起来的问题，还真有点不太清楚为什么有这样的定义。既然不明白就抽时间研究下吧。

enum的简单创建，

 enum Weekday {
     SUNDAY, MONDAY, TUESDAY, WEDNSDAY, THURSDAY, FRIDAY, SATURDAY
 };

如果要进行枚举的赋值，则要重新 私有的构造函数，构造函数的参数类型就是枚举值得类型，具体如下：

public enum HandlerCase {
    	// 利用构造函数传参
    	SDCARD_NO_FOUND(-2), 
    	NOT_WORK(-1), 
    	GET_DATA(0);
    	
    	// 定义私有变量
        private int nCode ;
        // 构造函数，枚举类型只能为私有
        private HandlerCase( int _nCode) {
            this . nCode = _nCode;
        }
        @Override
        public String toString() {
            return String.valueOf ( this . nCode );
        }
    }

一：如何正确理解enum类型？

enum Color { red, white, blue};
Color x;

我们应说x是Color类型的，而不应将x理解成enumeration类型，更不应将其理解成int类型。

理解此类型的最好的方法是将这个类型的值看成是red, white和blue，而不是简单将看成int值。

二：enum与int、String之间的转换

1、简单的枚举的转换

enum<->int

enum -> int: int i = enumType.value.ordinal();
int -> enum: enumType b= enumType.values()[i];

enum<->String

enum -> String: enumType.name()

String -> enum: enumType.valueOf(name); 

2、有初始变量值的转换

enum<->int

public enum HandlerCase {
    	// 利用构造函数传参
    	SDCARD_NO_FOUND(-2), 
    	NOT_WORK(-1), 
    	GET_DATA(0);
    	
    	// 定义私有变量
        private int nCode ;
        // 构造函数，枚举类型只能为私有
        private HandlerCase( int _nCode) {
            this . nCode = _nCode;
        }
        @Override
        public String toString() {
            return String.valueOf ( this . nCode );
        }
        
        public int toInt() {
            return this . nCode ;
        }
        
        // Implementing a from int method on an enum type
        private static final Map<Integer, HandlerCase> intToEnum = new HashMap<Integer, HandlerCase>();
        static {
            // Initialize map from constant name to enum constant
            for(HandlerCase blah : values()) {
            	intToEnum.put(blah.toInt(), blah);
            }
        }
        
        // Returns HandlerCase for int
        public static HandlerCase fromString(int symbol) {
            return intToEnum.get(symbol);
        }
    }

转换方法：

HandlerCase i = HandlerCase.fromString(-1);
int j = i.toInt();

enum<->String

也类似和int转换相同，只是Map的存储类型不一样，要重写toString（）方法。

三：enum的应用，包括定义，遍历，switch，enumset，enummap等

Java代码 

 import java.util.EnumMap;
 import java.util.EnumSet;
 public class EnumTest {
     // 定义一个enum枚举类型，包括两个实例ON，OFF
     public enum State {
         ON, OFF
     };
     // 测试函数
     public static void main(String[] args) {
         // 直接变量enum
         for (State s : State.values())
             System.out.println(s.name());
         // switch与enum的结合使用
         State switchState = State.OFF;
         switch (switchState) {
         case OFF:
             System.out.println("OFF");
             break;
         case ON:
             System.out.println("ON");
             break;
         }
         // EnumSet的使用
         EnumSet<State> stateSet = EnumSet.allOf(State.class);
         for (State s : stateSet) {
             System.out.println(s);
         }
         // EnumMap的使用
         EnumMap<State,String> stateMap = new EnumMap<State,String>(State.class);
         stateMap.put(State.ON, "is On");
         stateMap.put(State.OFF, "is off");
         for (State s : State.values()) {
             System.out.println(s.name() + ":" + stateMap.get(s));
         }
     }
 }

 

 

 package com.aicent.test;
 public enum TestEnumMathod {
     // 为每个enum实例添加不同的实现方法
     SAMPLE1 {
         String getInfo() {
             return "SAMPLE1";
         }
     },
     SAMPLE2 {
         String getInfo() {
             return "SAMPLE2";
         }
     };
     abstract String getInfo();
     // 测试
     public static void main(String args[]) {
         for (TestEnumMathod method : values()) {
             System.out.println(method.getInfo());
         }
     }
 }

枚举类型既然是类，那么也就可以有构造函数。只不过不得有公开(Public)的构造函数，这是为了避免直接对枚举类型实例化。如下代码：

 public class DetailActioin2
 {
      TURN_LEFT("向左转"),TURN_RIGHT("向右转"),SHOOT("射击");

      private String description;

      //不公开的构造函数
    private DetailAction2(String description)
        {
              this.description = description;
        }

      public String getDescription()
        {
              return description;
        }
 }

   非公开的构造函数最常见的一个例子就是singleton模式的应用，当某个类只能有一个实例时，可由类维护唯一的实例，这时可以将构造函数设定为私有，取用此类的开发人员就不能自行新增多个实例了。Singleton模式的简易版本代码如下：

 public class Singleton
 {
      //构造函数私有，只限内部调用
    private SingleTon(){};

      private static Singleton instance = null;

      public static synchronized SingleTon getInstance()
          {
                 if(instance == null)
                    instance = new Singleton();
                 return instance;
          }
 }