枚举类和普通静态值类的区别

先来一个枚举来举例子

 1 /**
 2  * 
 3  */
 4 public enum  LogType {
 5     /**
 6      * 新增
 7      */
 8     ADD("36010100","ADD"),
 9     /**
10      * 修改
11      */
12     EDIT("36010101","EDIT"),
13     /**
14      * 删除
15      */
16     DEL("36010102","DEL"),
17     /**
18      * 查看
19      */
20     VIEW("--","VIEW"),
21     /**
22      * 默认无操作
23      */
24     NULL("","NULL"),
25     /**
26      * 回滚操作
27      */
28     ROLLBACK("36010103","ROLLBACK");
29     private String operateTypeKey;
30     private String operateType;
31     LogType(String key,String operateType){
32         this.operateTypeKey = key;
33         this.operateType = operateType;
34     }
35 
36     public String getOperateTypeKey() {
37         return operateTypeKey;
38     }
39 
40     public void setOperateTypeKey(String operateTypeKey) {
41         this.operateTypeKey = operateTypeKey;
42     }
43 
44     public String getOperateType() {
45         return operateType;
46     }
47 
48     public void setOperateType(String operateType) {
49         this.operateType = operateType;
50     }
51 
52     @Override
53     public String toString() {
54         return "AspectOperation{" +
55                 "operateTypeKey='" + operateTypeKey + '\'' +
56                 ", operateType='" + operateType + '\'' +
57                 '}';
58     }
59 }

在这个枚举当中可以看到例举了几种操作的类型，增加，修改，删除，查看，回滚的操作。

以及反编译之后的结果

 1 public enum LogType
 2 {
 3   ADD("36010100", "ADD"), 
 4 
 5   EDIT("36010101", "EDIT"), 
 6 
 7   DEL("36010102", "DEL"), 
 8 
 9   VIEW("--", "VIEW"), 
10 
11   NULL("", "NULL"), 
12 
13   ROLLBACK("36010103", "ROLLBACK");
14 
15   private String operateTypeKey;
16   private String operateType;
17 
18   private LogType(String key, String operateType) { this.operateTypeKey = key;
19     this.operateType = operateType; }
20 
21   public String getOperateTypeKey()
22   {
23     return this.operateTypeKey;
24   }
25 
26   public void setOperateTypeKey(String operateTypeKey) {
27     this.operateTypeKey = operateTypeKey;
28   }
29 
30   public String getOperateType() {
31     return this.operateType;
32   }
33 
34   public void setOperateType(String operateType) {
35     this.operateType = operateType;
36   }
37 
38   public String toString()
39   {
40     return "AspectOperation{operateTypeKey='" + this.operateTypeKey + '\'' + ", operateType='" + this.operateType + '\'' + '}';
41   }
42 }

可以看到在其构造函数当中，构造函数是private说明，其在创建的时候无法实例化枚举类型。但是他可以拥有自己的构造方法，一个私有值，和get set的方法，以及通过get方法返回你需要的，但是这边的set方法已经失去了它本身的意义，完全可以去除。

下面看一下静态值类

1 public class LogTypeStatic {
2     public final static String ADD="ADD";
3     public final static String Eidt="EDIT";
4     public final static String DEL="DEL";
5     public final static String NULL="NULL";
6     public final static String VIEW="VIEW";
7 }

静态值类很简单,罗列的几种出现的类型，简单的调用方式就不在这边赘述了。下面通过一个例子表示一下枚举类型在使用的时候的优势。

1 @Test
2     public void testLogType(){
3         LogType [] logType = LogType.values();
4         for(int i=0;i<logType.length;i++){
5             System.out.print(logType[i]);
6         }
7     }

枚举类有自己的可以遍历自己所有的值，当成一个集合来使用，在使用的时候如果有新的类型添加进来，直接在枚举类型当中进行修改，值需要修改这个类即可，其他设涉及到这边的类文件不需要修改，同时也可以映射到

将枚举的类型看成一个集合来继续处理，这样的处理方式比静态值的处理方式明显优越很多，易于扩展。方法之间的参数传递就通过枚举类来进行传递，而不通过String类型来进行传递，更加易于理解，在代码里面也有更多的含义。

转载于:https://www.cnblogs.com/binarysheep/p/5897277.html