Java 005 枚举

public final String name()
Returns the name of this enum constant, exactly as declared in its enum declaration. Most programmers should use the toString() method in preference to this one, as the toString method may return a more user-friendly name. This method is designed primarily for use in specialized situations where correctness depends on getting the exact name, which will not vary from release to release.

public String toString()
Returns the name of this enum constant, as contained in the declaration. This method may be overridden, though it typically isn't necessary or desirable. An enum type should override this method when a more "programmer-friendly" string form exists.

System.out.println(Week.Monday) ---> Week.Monday 默认调用toString()方法

枚举概述：就是有有限值的集合或类。
是指将变量的值一一列出来， 变量的值只限于列举出来的值得范围。 举例： 一周7天， 一年12个月等。
回想单列设计模式： 单例类是一个类只有一个实例。
那么多例类就是一个类有多个实例， 但不是无限个数的实例， 而是有限个数的实例。 这才能是枚举类。

通过自定义一个枚举类:

 1 // 第一版：Simple
 2 public class UD_Enum {
 3     public static final UD_Enum FRONT = new UD_Enum();
 4     public static final UD_Enum BEHIND = new UD_Enum();
 5     public static final UD_Enum LEFT = new UD_Enum();
 6     public static final UD_Enum RIGHT = new UD_Enum();
 7 
 8     private UD_Enum() {
 9 
10     }
11 }
12 
13 // 第二版：Medium
14 public class UD_Enum2 {
15     public static final UD_Enum2 FRONT = new UD_Enum2("FRONT");
16     public static final UD_Enum2 BEHIND = new UD_Enum2("BEHIND");
17     public static final UD_Enum2 LEFT = new UD_Enum2("LEFT");
18     public static final UD_Enum2 RIGHT = new UD_Enum2("RIGHT");
19 
20     private String name;
21 
22     public String getName() {
23         return this.name;
24     }
25 
26     private UD_Enum2(String name) {
27         this.name = name;
28     }
29 
30     private UD_Enum2() {
31     }
32 }
33 
34 // 第三版： Complex
35 public abstract class UD_Enum3 {
36     public static final UD_Enum3 FRONT = new UD_Enum3("FRONT") {
37         @Override
38         public void show() {
39             System.out.println("this is front");
40         }
41     };
42     public static final UD_Enum3 BEHIND = new UD_Enum3("BEHIND") {
43         @Override
44         public void show() {
45             System.out.println("this is behind");
46         }
47     };
48     public static final UD_Enum3 LEFT = new UD_Enum3("LEFT") {
49         @Override
50         public void show() {
51             System.out.println("this is left");
52         }
53     };
54     public static final UD_Enum3 RIGHT = new UD_Enum3("RIGHT") {
55         @Override
56         public void show() {
57             System.out.println("this is right");
58         }
59     };
60 
61     private String name;
62 
63     public String getName() {
64         return this.name;
65     }
66 
67     private UD_Enum3(String name) {
68         this.name = name;
69     }
70 
71     private UD_Enum3() {
72     }
73 
74     public abstract void show();
75 }
class EnumDemo {
    public static void main(String[] args) {
        System.out.println("-------------- User Defined Enum - Simple ----------------------");
        UD_Enum ud1 = UD_Enum.BEHIND;
        System.out.println(ud1);

        System.out.println("-------------- User Defined Enum - Medium ----------------------");
        UD_Enum2 ud2 = UD_Enum2.LEFT;
        System.out.println(ud2);
        System.out.println(ud2.getName());

        System.out.println("-------------- User Defined Enum - Implex ----------------------");
        UD_Enum3 ud3 = UD_Enum3.RIGHT;
        System.out.println(ud3);
        System.out.println(ud3.getName());
        ud3.show();
    }
}

-- Console output ----
-------------- User Defined Enum - Simple ----------------------
com.java.test.UD_Enum@1db9742
-------------- User Defined Enum - Medium ----------------------
com.java.test.UD_Enum2@106d69c
LEFT
-------------- User Defined Enum - Implex ----------------------
com.java.test.UD_Enum3$4@52e922
RIGHT
this is right

发现自定义一个枚举类比较麻烦， 所以java就提供了枚举类供我们使用。
格式是： 只有枚举项的枚举类

public enum 枚举类名{
　　枚举项1， 枚举项2， 枚举项3.........;
}

 1 class EnumUtil {
 2     public static enum Browser {
 3         CHROME,
 4         IE,
 5         FIREFOX,
 6         HTMLUNIT
 7     }
 8  
 9 /**
10  * ReportOptions.Client.name() -- 内置的方法， 返回自身的字符串值  比如 返回的是 Client  
11  * 既然枚举类型提供了构造函数，我们可以通过构造函数和覆写toString 方法来实现。
12  * 首先给枚举类型增加构造方法，然后每个枚举类型的值通过构造函数传入对应的参数，
13  * 同时覆写toString 方法，在该方法中返回从构造函数中传入的参数，改造后的代码如下：
14  * @author LL-CC
15  */
16     public static enum ReportOptions{
17         Client("Client Document Upload"),
18         Color("Report Color Upload"),
19         Position("Report Position Upload");      
20             
21         private String value;
22         private ReportOptions(String value){
23             this.value = value;
24         }
25          
26         public String toString() {
27             return this.value;
28         }
29     }
30 }


注意事项：

  • 定义枚举类要用关键字Enum
  • 所有枚举类都是Enum的子类
  • 枚举类的第一行必须是枚举项， 最后一个枚举项的分号是可以省略的， 但是如果枚举类有其他的东西， 这个分号不能省略。 建议不要省略
  • 枚举类也可以由构造函数， 但必须是private的， 它默认的也是private的。 枚举项的用法比较特殊， 枚举("")
  • 枚举类也可以有抽象方法， 但是枚举项必须重写该方法
  • 枚举在switch语句中的使用
 1 public enum EnumComplex {
 2     FRONT("front") {
 3         @Override
 4         public void show() {
 5             System.out.println("I choose front");
 6         }
 7     },
 8     BEHIND("behind") {
 9         @Override
10         public void show() {
11             System.out.println("I choose behind");
12         }
13     },
14     LEFT("left") {
15         @Override
16         public void show() {
17             System.out.println("I choose left");
18         }
19     },
20     RIGHT("right") {
21         @Override
22         public void show() {
23             System.out.println("I choose right");
24         }
25     };
26     private String name;
27 
28     public String getName() {
29         return name;
30     }
31 
32     private EnumComplex(String name) {
33         this.name = name;
34     }
35 
36     public abstract void show();
37 }
38 
39     public static void main(String[] args) {
40 
41         System.out.println("-------------- Java Enum - Simple ----------------------");
42         EnumSimple ed1 = EnumSimple.RIGHT;
43         System.out.println(ed1);
44 
45         System.out.println("-------------- Java Enum - Complex ----------------------");
46         EnumComplex ed2 = EnumComplex.LEFT;
47         System.out.println(ed2);
48         System.out.println(ed2.getName());
49         ed2.show();
50 
51         switch (ed2) {
52         case FRONT:
53             System.out.println("front");
54             break;
55         case BEHIND:
56             System.out.println("Behind");
57             break;
58         case LEFT:
59             System.out.println("left");
60             break;
61         case RIGHT:
62             System.out.println("right");
63             break;
64         }
65     }


枚举和类常量的对比：
1. 枚举类型是强类型的，从而保证了系统安全性。而以类的静态字段实现的类来替代枚举，不具有枚举的简单性和类型安全性。
把一个表示星期一到星期天的枚举类作为方法参数的时， 只能传递枚举项 限制了可以传递的范围 重点是限制 他给你类型 然后你去选择类型 这跟以前的判断方式肯定是不同的
枚举可以限定参数的个数，对调用者的行为能更加严格地进行控制。把一些运行期的参数检查放到了编译期，做到这点是一个很大的进步。 int 1-7 表示星期一到星期天， 作为参数传递时， 比如 0， 9 来调编译不会报错， 运行是就会出错。 枚举类型则可以将一个类型限制在可控制的范围内。

2. 枚举类型使代码更具可读性，理解清晰，易于维护。方便的代码机制。同时，如果枚举符号和对应的整数值发生变化，只需修改枚举定义即可，而不必在漫长的代码中进行修改。
表示星期1-7,你可以用int1-7,但是当你把它作为参数的时候,有时后你就给考虑传入0,8的情况.而且用数字表示还需要相应的注释和文档. 这个时候你定义个一个枚举,名字就叫字面就叫Monday , Tuesday ,....就行,直观,并且值可控.
如果要定义100个常量时候 你就知道枚举的好处了 包糖衣还是很有用的

静态常量其实是枚举模式的应用， 但它有很多缺点
* 类型不安全（静态常量可以随意增加使用或操作）
* 无命名空间，
* 脆弱（某常量值改变后客户端如果不编译热人仍能使用）
* 静态常量打印值为数字
* 不具有提示性

假如有一笔业务需要审核，审核状态分：未审核，审核中，审核通过，审核不通过。我们在程序里是否可以直接这么写：
if(state==1){//1代表未操作
//操作
}else{
//......
}
将状态标识直接写在代码里面（硬编码），只图一时方便，却是后患无穷，如果有一天你需要修改状态标识，用0代表未审核而不是1，你不得不将所有与该标识相关的代码都找出来一个个改，另外，在编码过程中，标识输入错误的概率是比较高的，一不小心把0输入成了10，虽然不会提示任何编译错误，但运行结果将是出乎人的意料的。
于是我们很快想到可以用常量代替：
public static final int UNAUDIT = 0;
相关判断代码则是:
if(state==CONSTANT.UNAUDIT){
//操作
}else{
//......
}
这段代码比硬编码更加健壮容易维护，但是仍然有不足之处。
1、UNAUDIT是编译期常量，如果其值被改变，那么使用方需要重新编译。
2、没有简便的方法获取标识代表的字符串描述。
于是我们用枚举类来代替常量。
public enum AuditState {
UNAUDIT(1),
AUDITING(2),
AUDIT_SUCCESS(3),
AUDIT_FAIL(4);
private final int statenum;
AuditState(int statenum){
this.statenum = statenum;
}
public int getStatenum() {
return statenum;
}
}
调用如下：
if (state == AuditState.UNAUDIT.getStatenum()) {
//AuditState.UNAUDIT.toString()获取字符串描述
System.out.println(AuditState.UNAUDIT.toString() + "标识是 "
+ AuditState.UNAUDIT.getStatenum());
} else {
//......
}
枚举类还有更加强大的功能，如添加字段，方法，还可以对他进行遍历访问

虽然枚举在很多方面都比接口常量和类常量好用，但是它有一点比不上接口常量和类常量的，就是继承，枚举类型是不能有继承的，也就是说一个枚举常量定义完毕后，除非修改重构，否则无法做扩展。

三、建议
在项目开发中，推荐使用枚举常量代替接口常量或类常量。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/zi-yao/p/6246446.html