常量与枚举
一、常量定义方法
常量是其值固定不变的量，一般可以分为字面常量和命名常量，如数字1，2，1.3，字符串“abc”，这些就是字面常量，而命名常量是我们使用一些有意义的名称来代表字面常量值，通常命名常量有助于我们更好地理解程序的逻辑。
在Java中，我们通常使用public static final ... 方式来定义常量，如： public static final int MAX_VALUE = 1000;
在JDK1.5之前，我们如果需要表示一组相关的常量，可以使用如下方法完成：
01./**
02. * 星期
03. * @author
04. *
05. */
06.public class WeekDay {
07. public static final int MONDAY = 1; // 星期一
08. public static final int TUESDAY = 2; // 星期二
09. public static final int WEDNESDAY = 3; // 星期三
10. public static final int THURSDAY = 4; // 星期四
11. public static final int FRIDAY = 5; // 星期五
12. public static final int SATURDAY = 6; // 星期六
13. public static final int SUNDAY = 0; // 星期日
14.}
现在好了，我们可以把相关的常量封装到一个枚举类型中，而且枚举还提供了比常量更多的方法。
二、枚举定义方法
枚举的简单定义方法如下：
01./**
02. * 星期枚举
03. * @author
04. *
05. */
06.public enum WeekDay {
07. MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
08.}
那我们能不能像使用常量一样给每个枚举类型一个数值呢，答案是肯定的。
默认情况下，每个枚举值对应一个整型数字值。第一个枚举值对应数字0，第二个枚举值对应数字1，以后每个枚举值所对应数字是（前一个枚举数值+1）的结果。当然，我们也可以自己重新给每个枚举值指定一个数值。
如何实现自定义每个枚举值对应的数字值呢？枚举类型提供了构造方法，我们可以通过构造方法与toString()方法来实现。则改造后的代码如下：
01./**
02. * 星期枚举
03. *
04. * @author
05. *
06. */
07.public enum WeekDay {
08. // 利用构造方法传参
09. MONDAY(1), TUESDAY(2), WEDNESDAY(3), THURSDAY(4), FRIDAY(5), SATURDAY(6), SUNDAY(0);
10.
11. private int val;
12.
13. private WeekDay(int val) {
14. this.val = val;
15. }
16.
17. @Override
18. public String toString() {
19. return String.valueOf(this.val);
20. }
21.}
由此看来，枚举中我们也可以定义成员变量与构造方法。
但需要注意的是，枚举类的构造方法与普通类的构造方法有很大的不同： ?枚举构造方法只在构造枚举值时被调用 ?枚举构造方法只能是private私有的，不能为public公有的
枚举中还可以定义成员方法，改造后的代码如下：
01./**
02. * 星期枚举
03. *
04. * @author
05. *
06. */
07.public enum WeekDay {
08. // 利用构造方法传参
09. MONDAY("星期一", 1, 1), TUESDAY("星期二", 2, 2), WEDNESDAY("星期三", 3, 3), THURSDAY(
10. "星期四", 4, 4), FRIDAY("星期五", 5, 5), SATURDAY("星期六", 6, 6), SUNDAY(
11. "星期日", 0, 7);
12.
13. private String name; // 中文名称
14. private int val; // 对应数字值
15. private int index; // 索引
16.
17. private WeekDay(String name, int val, int index) {
18. this.name = name;
19. this.val = val;
20. this.index = index;
21. }
22.
23. /**
24. * 获取中文名称
25. *
26. * @return 中文名称字符串
27. */
28. public String getName() {
29. return this.name;
30. }
31.
32. /**
33. * 获取枚举值对应数值
34. *
35. * @return 枚举对应数值
36. */
37. public int getVal() {
38. return this.val;
39. }
40.
41. /**
42. * 获取枚举值索引
43. *
44. * @return 索引
45. */
46. public int getIndex() {
47. return this.index;
48. }
49.
50. /**
51. * 设置中文名称
52. *
53. * @param name
54. * 中文名称
55. */
56. public void setName(String name) {
57. this.name = name;
58. }
59.
60. /**
61. * 设置数字值
62. *
63. * @param val
64. * 数值
65. */
66. public void setVal(int val) {
67. this.val = val;
68. }
69.
70. /**
71. * 设置索引
72. *
73. * @param index
74. * 索引
75. */
76. public void setIndex(int index) {
77. this.index = index;
78. }
79.
80. /**
81. * 根据索引获取枚举值中文名称
82. *
83. * @param index
84. * 索引
85. * @return 该索引枚举值中文名称
86. */
87. public static String getName(int index) {
88. for (WeekDay weekDay : WeekDay.values()) {
89. if (weekDay.getIndex() == index)
90. return weekDay.getName();
91. }
92.
93. return null;
94. }
95.
96. @Override
97. public String toString() {
98. return "WeekDay " + super.toString() + "[name=" + this.name + " val="
99. + this.val + " index=" + this.index + "]";
100. }
101.}
关于使用枚举类型的说明
所有枚举都继承了Enum的方法，下面详细介绍这些方法：
1.ordinal()：返回枚举值在枚举中的顺序，这个顺序是按照枚举值定义的顺序从0开始依次递增的
2.name()：返回枚举值的名称
3.compartTo(E)：因Enum实现了Comparable接口，因此可以比较此对象与指定对象的顺序
4.values()：返回一个包含全部枚举值的数组
5.toString()：返回枚举值的名称
6.valueOf(String)/valueOf(Class, String)：返回带指定名称的指定枚举类型的枚举值
7.equals(Object)：比较两个枚举对象的引用
我们可以将枚举看作是类，并且是一个不能被继承的final类，其枚举值是类的静态常量，我们可以通过如下语法来获取枚举的一个实例，如WeekDay wd = WeekDay.MONDAY;
一个完整的示例：
01.public class WeekDayTest {
02.
03. /**
04. * 定义枚举类型
05. */
06. public enum WeekDay {
07. // 利用构造方法传参
08. MONDAY("星期一", 1, 1), TUESDAY("星期二", 2, 2), WEDNESDAY("星期三", 3, 3), THURSDAY(
09. "星期四", 4, 4), FRIDAY("星期五", 5, 5), SATURDAY("星期六", 6, 6), SUNDAY(
10. "星期日", 0, 7);
11.
12. private String name; // 中文名称
13. private int val; // 对应数字值
14. private int index; // 索引
15.
16. private WeekDay(String name, int val, int index) {
17. this.name = name;
18. this.val = val;
19. this.index = index;
20. }
21.
22. /**
23. * 获取中文名称
24. *
25. * @return 中文名称字符串
26. */
27. public String getName() {
28. return this.name;
29. }
30.
31. /**
32. * 获取枚举值对应数值
33. *
34. * @return 枚举对应数值
35. */
36. public int getVal() {
37. return this.val;
38. }
39.
40. /**
41. * 获取枚举值索引
42. *
43. * @return 索引
44. */
45. public int getIndex() {
46. return this.index;
47. }
48.
49. /**
50. * 设置中文名称
51. *
52. * @param name
53. * 中文名称
54. */
55. public void setName(String name) {
56. this.name = name;
57. }
58.
59. /**
60. * 设置数字值
61. *
62. * @param val
63. * 数值
64. */
65. public void setVal(int val) {
66. this.val = val;
67. }
68.
69. /**
70. * 设置索引
71. *
72. * @param index
73. * 索引
74. */
75. public void setIndex(int index) {
76. this.index = index;
77. }
78.
79. /**
80. * 根据索引获取枚举值中文名称
81. *
82. * @param index
83. * 索引
84. * @return 该索引枚举值中文名称
85. */
86. public static String getName(int index) {
87. for (WeekDay weekDay : WeekDay.values()) {
88. if (weekDay.getIndex() == index)
89. return weekDay.getName();
90. }
91.
92. return null;
93. }
94.
95. @Override
96. public String toString() {
97. return "WeekDay - " + super.toString() + "[name=" + this.name
98. + ", val=" + this.val + ", index=" + this.index + "]";
99. }
100. }
101.
102. public static void main(String[] args) {
103. // 遍历所有枚举值
104. for (WeekDay weekDay : WeekDay.values()) {
105. System.out.println(weekDay);
106. }
107. System.out.println("************************************");
108. // 将字符串“FRIDAY”转换为枚举类型
109. WeekDay wd = WeekDay.valueOf("FRIDAY");
110. // 输出转换后星期的中文名称，数字值及自定义索引值，枚举值顺序值，枚举值名称
111. System.out.println("中文名称：" + wd.getName());
112. System.out.println("数字值：" + wd.getVal());
113. System.out.println("自定义索引值：" + wd.getIndex());
114. System.out.println("顺序值：" + wd.ordinal());
115. System.out.println("枚举值名称：" + wd.name());
116. System.out.println("************************************");
117. // 比较两个枚举实例是否一致
118. System.out.println("两个枚举实例是否一致：" + wd.equals(WeekDay.FRIDAY));
119. // 比较两个枚举值大小
120. System.out.println("两个枚举值大小：" + WeekDay.MONDAY.compareTo(WeekDay.FRIDAY));
121. }
122.}
运行结果：
WeekDay - MONDAY[name=星期一, val=1, index=1]
WeekDay - TUESDAY[name=星期二, val=2, index=2]
WeekDay - WEDNESDAY[name=星期三, val=3, index=3]
WeekDay - THURSDAY[name=星期四, val=4, index=4]
WeekDay - FRIDAY[name=星期五, val=5, index=5]
WeekDay - SATURDAY[name=星期六, val=6, index=6]
WeekDay - SUNDAY[name=星期日, val=0, index=7]
************************************
中文名称：星期五 数字值：5 自定义索引值：5 顺序值：4 枚举值名称：FRIDAY
************************************
两个枚举实例是否一致：true 两个枚举值大小：-4
来源：https://www.cnblogs.com/lxh1197412986/p/4540658.html