JAVA应用开发之枚举技术

枚举类型是JDK5.0的新特征。Sun引进了一个全新的关键字enum来定义一个枚举类。
      
1.引出枚举
     在实际编程中，往往存在着这样的“数据集”，它们的数值在程序中是稳定的，而且“数据集”中的元素是有限的。例如星期一到星期日七个数据元素组成了一周的“数据集”，春夏秋冬四个数据元素组成了四季的“数据集”。在 Java 中想表示这种数据集最容易想到的写法可能是这样，我们以表示一周五天的工作日来举例：

1. public class WeekDay {
   
2.         public static final int MONDAY = 1;
   
3.         public static final int TUESDAY = 2;
   
4.         public static final int WENSDAY = 3;
   
5.         public static final int THURSDAY = 4;
   
6.         public static final int FRIDAY = 5;
   
7. }

复制代码

现在，你的类就可以使用像WeekDay.TUESDAY这样的常量了。但是这里隐藏着一些问题，这些常量是Java中int类型的常量，这意味着该方法可以接受任何int 类型的值，即使它和WeekDay中定义的所有日期都对应不上。因此，您需要检测上界和下界，在出现无效值的时候，可能还要抛出一个IllegalArgumentException。而且，如果后来又添加另外一个日期（例如WeekDay.SATURDAY ），那么必须改变所有代码中的上界，才能接受这个新值。 换句话说，在使用这类带有整型常量的类时，这个方案也许可行，但并不是非常有效。

     Joshua Bloch老大这时站了出来，在他的著作《Effective Java》中提出了在这样场景下的一种非常好的模式——Type-safe enumeration pattern。这个模式简而言之就是给这样的常量类一个私有的构造方法，然后声明一些public static final的同类型的变量暴露给使用者，例如：

public class WeekDay {
         public static final WeekDay MONDAY = new WeekDay(1);
         public static final WeekDay TUESDAY = new WeekDay(2);
         public static final WeekDay WENSDAY = new WeekDay(3);
         public static final WeekDay THURSDAY = new WeekDay(4);
         public static final WeekDay FRIDAY = new WeekDay(5);
        
         public int getValue(){
                   return value;
         }
        
         private int value;
        
         private WeekDay(int i){
                   this.value = i;
         }
         //other methods...
}

这样做的好处是你的程序现在接受的不是int类型的数据了，而是WeekDay的一个预定义好的static final的实例（WeekDay.TUESDAY等）

2.枚举以及枚举模板（template)

        我们来看一个枚举类型使用的小例子。需求中要求可以对指定的日期进行相应的信息输出。对于这么简单的需求，这里就使用枚举类型来进行处理。前面我们已经定义好了包含有五个工作日的枚举类型。下面的代码则是进行输出的方法：

1. package com.aaa.java2.enumapp;
   
2. 
   
3. public enum WeekDay {
   
4.         MONDAY {
   
5.                 @Override
   
6.                 public void printWeekDay() {
   
7.                         System.out.println("Today is Monday!");
   
8.                 }
   
9.         },
   
10.         TUESDAY {
    
11.                 @Override
    
12.                 public void printWeekDay() {
    
13.                         System.out.println("Today is Tuesday!");
    
14.                 }
    
15.         },
    
16.         WENSDAY {
    
17.                 @Override
    
18.                 public void printWeekDay() {
    
19.                         System.out.println("Today is Wensday!");
    
20.                 }
    
21.         },
    
22.         THURSDAY {
    
23.                 @Override
    
24.                 public void printWeekDay() {
    
25.                         System.out.println("Today is Thursday!");
    
26.                 }
    
27.         },
    
28.         FRIDAY {
    
29.                 @Override
    
30.                 public void printWeekDay() {
    
31.                         System.out.println("Today is Friday!");
    
32.                 }
    
33.         };
    
34. 
    
35.         /**
    
36.          * 根据工作日的不同打印不同的信息
    
37.          */
    
38.         public abstract void printWeekDay();
    
39. }

复制代码

然后就是它的客户端类:

1. package com.aaa.java2.enumapp;
   
2. 
   
3. /**
   
4. * 说说Java中的枚举——模板方法
   
5. * @author LONMID
   
6. *
   
7. */
   
8. public class WeekDayClient {
   
9. 
   
10.         public static void main(String[] args) {
    
11.                 for(WeekDay weekDay:WeekDay.values()){
    
12.                         weekDay.printWeekDay();
    
13.                         System.out.println("枚举索引值：\t"+weekDay.ordinal());
    
14.                 }
    
15.         }
    
16.         
    
17. }

复制代码

下面再举一例：

2.1  申明接口

package com.aaa.java2.enumapp.advance2;
public interface Operation {
    double apply(double x,double y);
}

2.2 两个实现类  BasicOperation  和  ExtendedOperation  

1. package com.aaa.java2.enumapp.advance2;
   
2. 
   
3. public enum BasicOperation implements Operation {
   
4.         PLUS("+") {
   
5.                 public double apply(double x, double y) {
   
6.                         return x + y;
   
7.                 }
   
8.         },
   
9.         MINUS("-") {
   
10.                 public double apply(double x, double y) {
    
11.                         return x - y;
    
12.                 }
    
13.         },
    
14.         TIMES("*") {
    
15.                 public double apply(double x, double y) {
    
16.                         return x * y;
    
17.                 }
    
18.         },
    
19.         DIVIDE("/") {
    
20.                 public double apply(double x, double y) {
    
21.                         return x / y;
    
22.                 }
    
23.         };
    
24.         private final String symbol;
    
25. 
    
26.         BasicOperation(String symbol) {
    
27.                 this.symbol = symbol;
    
28.         }
    
29. 
    
30.         @Override
    
31.         public String toString() {
    
32.                 return symbol;
    
33.         }
    
34. }

复制代码

1. package com.aaa.java2.enumapp.advance2;
   
2. 
   
3. public enum ExtendedOperation implements Operation {
   
4.     EXP("^") {
   
5.         public double apply(double x,double y) {
   
6.             return Math.pow(x,y);
   
7.         }
   
8.     },
   
9.     REMAINDER("%") {
   
10.         public double apply(double x,double y) {
    
11.             return x % y;
    
12.         }
    
13.     };
    
14.     private final String symbol;
    
15.     ExtendedOperation(String symbol) {
    
16.         this.symbol = symbol;
    
17.     }
    
18.     @Override public String toString() {
    
19.         return symbol;
    
20.     }
    
21. }

复制代码

2.3 最后它的客户端类

1. package com.aaa.java2.enumapp.advance2;
   
2. 
   
3. /**
   
4. *  注意，参数Class<T> opSet将推演出类型参数的实际类型，即上例中的ExtendedOperation。
   
5. *  与此同时，test函数的参数类型限定确保了类型参数既是枚举类型又是Operation的实现类，
   
6. *  这正是遍历元素和执行每个元素相关联的操作所必须的。
   
7. * @author LONMID
   
8. *
   
9. */
   
10. public class Client {
    
11.         public static void main(String[] args) {
    
12.         double x = 1L;//Double.parseDouble(args[0]);
    
13.         double y =1L; // Double.parseDouble(args[1]);
    
14.         
    
15.         test(ExtendedOperation.class,x,y);
    
16.         //使用扩展操作类
    
17.     }
    
18.     private static <T extends Enum<T> & Operation> void test(
    
19.         Class<T> opSet,double x,double y) {
    
20.         for (Operation op : opSet.getEnumConstants()) {
    
21.             System.out.printf("%f %s %f = %f%n",x,op,y,op.apply(x,y));
    
22.         }
    
23.     }
    
24. }

复制代码

2.4 EnumMap的使用

          EnumMap是专门为枚举类型量身定做的Map实现。虽然使用其它的Map实现（如HashMap）也能完成枚举类型实例到值得映射，但是使用EnumMap会更加高效：它只能接收同一枚举类型的实例作为键值，并且由于枚举类型实例的数量相对固定并且有限，所以EnumMap使用数组来存放与枚举类型对应的值。这使得EnumMap的效率非常高。

    提示：EnumMap在内部使用枚举类型的ordinal()得到当前实例的声明次序，并使用这个次序维护枚举类型实例对应值在数组的位置。

2.4.1 申明枚举

1. package com.aaa.java2.enumapp.hashEnum2;
   
2. 
   
3. public enum DataBaseType{
   
4.     MYSQL,ORACLE,DB2,SQLSERVER
   
5. }

复制代码

2.4.2 枚举具体实现类

1. package com.aaa.java2.enumapp.hashEnum2;
   
2. 
   
3. import java.util.EnumMap;
   
4. 
   
5. public class DataBaseInfo {
   
6.         // 某类中定义的获取数据库URL的方法以及EnumMap的声明。
   
7.         private EnumMap<DataBaseType, String> urls = new EnumMap<DataBaseType, String>(DataBaseType.class); 
   
8.         // keyType the class object of the key type for this enum map
   
9. 
   
10.         public DataBaseInfo() {
    
11.                 urls.put(DataBaseType.DB2, "jdbc:db2://localhost:5000/sample");
    
12.                 urls.put(DataBaseType.MYSQL, "jdbc:mysql://localhost/mydb");
    
13.                 urls.put(DataBaseType.ORACLE, "jdbc:oracle:thin:@localhost:1521:sample");
    
14.                 urls.put(DataBaseType.SQLSERVER,
    
15.                                 "jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb");
    
16.         }
    
17. 
    
18.         /**
    
19.          * 根据不同的数据库类型，返回对应的URL
    
20.          * 
    
21.          * @param type
    
22.          *            DataBaseType枚举类新实例
    
23.          * @return
    
24.          */
    
25.         public String getURL(DataBaseType type) {
    
26.                 return this.urls.get(type);
    
27.         }
    
28. }

复制代码

2.4.3 客户端实现类

1. package com.aaa.java2.enumapp.hashEnum2;
   
2. 
   
3. public class Client {
   
4.   
   
5.         public static void main(String[] args) {
   
6.                 DataBaseInfo dbBaseInfo = new DataBaseInfo();
   
7.                 System.out.println(dbBaseInfo.getURL(DataBaseType.DB2));
   
8.         }
   
9.         
   
10. }

复制代码

最后再举一例
2.5  算术符枚举 

1. package com.aaa.java2.enumapp.advance;
   
2. 
   
3. import java.util.HashMap;
   
4. import java.util.Map;
   
5. 
   
6. public enum Operation {
   
7.         PLUS("+") {
   
8.                 double apply(double x, double y) {
   
9.                         return x + y;
   
10.                 }
    
11.         },
    
12.         MINUS("-") {
    
13.                 double apply(double x, double y) {
    
14.                         return x - y;
    
15.                 }
    
16.         },
    
17.         TIMES("*") {
    
18.                 double apply(double x, double y) {
    
19.                         return x * y;
    
20.                 }
    
21.         },
    
22.         DIVIDE("/") {
    
23.                 double apply(double x, double y) {
    
24.                         return x / y;
    
25.                 }
    
26.         };
    
27. 
    
28.         private final String symbol;
    
29. 
    
30.         Operation(String symbol) {
    
31.                 this.symbol = symbol;
    
32.         }
    
33. 
    
34.         @Override
    
35.         public String toString() {
    
36.                 return symbol;
    
37.         }
    
38. 
    
39.         abstract double apply(double x, double y);
    
40. 
    
41.         // 新增代码
    
42.         private static final Map<String, Operation> stringToEnum = new HashMap<String, Operation>();
    
43. 
    
44.         static {
    
45.                 for (Operation op : values())
    
46.                         stringToEnum.put(op.toString(), op);
    
47.         }
    
48. 
    
49.         public static Operation fromString(String symbol) {
    
50.                 return stringToEnum.get(symbol);
    
51.         }
    
52. 
    
53. }

复制代码

客户端实现类：

1. package com.aaa.java2.enumapp.advance;
   
2. 
   
3. public class Client {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                 double x =5L;  // Double.parseDouble(args[0]);
   
7.                 double y =10L;  //Double.parseDouble(args[1]);
   
8.                 for (Operation op : Operation.values())
   
9.                         System.out.printf("%f %s %f = %f%n", x, op, y, op.apply(x, y));
   
10.         }
    
11.         // 2.000000 + 4.000000 = 6.000000
    
12.         // 2.000000 - 4.000000 = -2.000000
    
13.         // 2.000000 * 4.000000 = 8.000000
    
14.         // 2.000000 / 4.000000 = 0.500000
    
15. 
    
16. }

复制代码

（完，待续...........................）

参考地址：
http://hi.baidu.com/chinakite/blog/item/f8d12697dc8f326a54fb9631.html  

http://www.cnblogs.com/stephen-liu74/archive/2012/01/23/2232218.html