package com.wanma.apps.enums;
import lombok.Getter;
/**
* 邮件任务启动类型
*/
@Getter
public enum TaskStartType {
START_NOT(1, "暂不发送"),
START_TIME(2, "定时发送"),
START_NOW(3, "立刻发送"),
;
private final int index;
private final String name;
/**
* 构造方法
*/
TaskStartType(int index, String name) {
this.index = index;
this.name = name;
}
/**
* 通过索引值获取名称
*/
public static String getName(int index) {
for (TaskStartType type : TaskStartType.values()) {
if (type.getIndex() == index) {
return type.getName();
}
}
return "";
}
/**
* 通过索引值获取枚举对象
*/
public static TaskStartType fromIndex(int index) {
for (TaskStartType type : TaskStartType.values()) {
if (type.getIndex() == index) {
return type;
}
}
return null;
}
}
用法一：常量
在JDK1.5 之前，我们定义常量都是： public static final.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。
public enum Color {
RED, GREEN, BLANK, YELLOW
}
用法二：switch
JDK1.6之前的switch语句只支持int,char类型，使用枚举，能让我们的代码可读性更强。
enum Signal {
GREEN, YELLOW, RED
}
public class TrafficLight {
Signal color = Signal.RED;
public void change() {
switch (color) {
case RED:
color = Signal.GREEN;
break;
case YELLOW:
color = Signal.RED;
break;
case GREEN:
color = Signal.YELLOW;
break;
}
}
}
用法三：【自定义枚举类】向枚举中添加新方法
如果打算自定义自己的方法，那么必须在Enum实例序列的最后添加一个分号。
而且 Java 要求必须先定义 Enum 实例。
public enum Color {
RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
// 成员变量
private String name;
private int index;
// 构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
// 普通方法
public static String getName(int index) {
for (Color c : Color.values()) {
if (c.getIndex() == index) {
return c.getName();
}
}
return null;
}
// get set 方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
}
可以通过定制 Enum 类型来定义自己的枚举类。需要注意的是枚举类型的构造函数是私有的 private，所以不能通过 New 来创建枚举类型，正因如此才保证了枚举数据类型的安全，不会被更改。如：定义一个 Day enum 类型：
public enum Day {
SUNDAY(7, "周日"), MONDAY(1, "周一"), TUESDAY(2, "周二"),
WEDNESDAY(3, "周三"), THURSDAY(4, "周四"), FRIDAY(5, "周五"),
SATURDAY(6, "周六");
private Integer code;
private String name;
Day(Integer code, String name) {
this.code = code;
this.name = name;
}
public Integer getCode() {
return code;
}
public String getName() {
return name;
}
}
测试：
public class EnumTest {
public static void main(String[] args) {
Day today = Day.WEDNESDAY;
switch (today) {
case MONDAY:
System.out.println(Day.MONDAY.getName());
break;
case TUESDAY:
System.out.println(Day.TUESDAY.getName());
break;
case WEDNESDAY:
System.out.println(Day.WEDNESDAY.getName());
break;
case THURSDAY:
System.out.println(Day.THURSDAY.getName());
break;
case FRIDAY:
System.out.println(Day.FRIDAY.getName());
break;
case SATURDAY:
System.out.println(Day.SATURDAY.getName());
break;
case SUNDAY:
System.out.println(Day.SUNDAY.getName());
break;
}
}
}
用法四：覆盖枚举的方法
下面给出一个toString()方法覆盖的例子。
public enum Color {
RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
// 成员变量
private String name;
private int index;
// 构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
// 覆盖方法
@Override
public String toString() {
return this.index+"_"+this.name;
}
}
用法五：实现接口
所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。
public interface Behaviour {
void print();
String getInfo();
}
public enum Color implements Behaviour {
RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
// 成员变量
private String name;
private int index;
// 构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
// 接口方法
@Override
public String getInfo() {
return this.name;
}
// 接口方法
@Override
public void print() {
System.out.println(this.index + ":" + this.name);
}
}
用法六：使用接口组织枚举
public interface Food {
enum Coffee implements Food{
BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO
}
enum Dessert implements Food{
FRUIT, CAKE, GELATO
}
}
/**
* 测试继承接口的枚举的使用（by 大师兄 or 大湿胸。）
*/
private static void testImplementsInterface() {
for (Food.DessertEnum dessertEnum : Food.DessertEnum.values()) {
System.out.print(dessertEnum + " ");
}
System.out.println();
// 我这地方这么写，是因为我在自己测试的时候，把这个coffee单独到一个文件去实现那个food接口，而不是在那个接口的内部。
for (CoffeeEnum coffee : CoffeeEnum.values()) {
System.out.print(coffee + " ");
}
System.out.println();
// 搞个实现接口，来组织枚举，简单讲，就是分类吧。如果大量使用枚举的话，这么干，在写代码的时候，就很方便调用啦。
// 还有就是个“多态”的功能吧，
Food food = Food.DessertEnum.CAKE;
System.out.println(food);
food = CoffeeEnum.BLACK_COFFEE;
System.out.println(food);
}
运行结果：
用法七：关于枚举集合的使用
7.1 EnumMap 枚举型映射/字典
EnumMap 是对 Map 接口的实现类，其 key-value 映射中的 key 是 Enum 类型，其原理是一个对象数组，数组的下标索引就是根据 Map 中的 key 直接获取（即枚举中的 ordinal 值），数组长度就是枚举类成员个数；当 key 为枚举类型时其效率比 HashMap 高，因为可以直接获取数组下标索引访问到元素；此外 EnumMap 是保证顺序的，输出是按照 key 在枚举中的顺序来确定的。
EnumMap 的构造方法
// 需要传递一个类型信息，因为没有这个类信息就不知道具体的枚举类是什么，
// 也就无法初始化内部的数据结构。
public EnumMap(Class < K > keyType)
// 其他构造方法。
public EnumMap(EnumMap < K, ? extends V > m )
public EnumMap(Map < K, ? extends V > m )
EnumMap 的实现原理
EnumMap 的实现原理依赖内部两个长度相同的数组，一个表示所有可能的键，一个表示对应的值，当放入 key-value 时首先会检查键的类型，如果类型不对会抛出异常，否则调用 key 的 ordinal 获取索引 index，并将值 value 放入值数组 vals[index] 中（注意：如果值 value 为 null，则为了区别真正的 null 与没有值，EnumMap 会将 null 值包装成一个特殊的对象）。
其构造方法主要就是在初始化相关数组，如下：
public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V> implements java.io.Serializable, Cloneable {
//key键的具体枚举类型
private final Class<K> keyType;
// key的所有枚举值
private transient K[] keyUniverse;
// EnumMap的存储实现，仅仅为一个枚举成员个数长度的数组
private transient Object[] vals;
......
// 构造方法
public EnumMap(Class<K> keyType) {
// key的枚举类型赋值
this.keyType = keyType;
// 获取枚举类的所有枚举值存入数组缓存使用
keyUniverse = getKeyUniverse(keyType);
// 实例化枚举值个数长度的数组
vals = new Object[keyUniverse.length];
}
......
}
测试
import java.util.EnumMap;
import java.util.HashMap;
import java.util.Map;
public class EnumMapTest {
public static void main(String[] args) {
EnumMap<Day,String> enumMap = new EnumMap<Day, String>(Day.class);
enumMap.put(Day.WEDNESDAY,"今天是周三");
Map<Day,String> map = new HashMap<>();
map.put(Day.WEDNESDAY,"今天是周三");
System.out.println("enumMap:"+enumMap.get(Day.WEDNESDAY));
System.out.println("map:"+map.get(Day.WEDNESDAY));
}
}
7.2 EnumSet 枚举集合
EnumSet 是个抽象类，不能实例化，查看源码发现有提供静态实例化 JumboEnumSet 或 RegularEnumSet 对象的方法。这两个对象继承自 EnumSet，区别在于 EnumSet 大小，大于 64 时创建的是 JumboEnumSet 对象，小于 64 时创建的是 RegularEnumSet 对象。
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.Map;
public class EnumMapTest {
public static void main(String[] args) {
EnumSet<Day> enumSet = EnumSet.noneOf(Day.class);
enumSet.add(Day.WEDNESDAY);
enumSet.add(Day.MONDAY);
System.out.println(enumSet.toString());
for (Day day:enumSet){
System.out.println("code:" + day.getCode()+"name:"+day.getName());
}
enumSet.clear();
System.out.println(enumSet);
}
}
输出：
[MONDAY, WEDNESDAY] code:1name:周一 code:3name:周三 []
EnumSet 是非线程安全的，要想线程安全使用 Collections.synchronizedSet() 处理 numSet 对象，如：
Set<Day> enumSet = Collections.synchronizedSet(EnumSet.noneOf(Day.class));
【推荐】个人实践
package com.lxk.enumTest;
/**
* Java枚举用法测试
*/
public class EnumTest {
public static void main(String[] args) {
forEnum();
useEnumInJava();
}
/**
* 循环枚举,输出ordinal属性；若枚举有内部属性，则也输出。(说的就是我定义的TYPE类型的枚举的typeName属性)
*/
private static void forEnum() {
for (SimpleEnum simpleEnum : SimpleEnum.values()) {
System.out.println(simpleEnum + " ordinal " + simpleEnum.ordinal());
}
System.out.println("------------------");
for (TYPE type : TYPE.values()) {
System.out.println("type = " + type + " type.name = " + type.name() + " typeName = " + type.getTypeName() + " ordinal = " + type.ordinal());
}
}
/**
* 在Java代码使用枚举
*/
private static void useEnumInJava() {
String typeName = "f5";
TYPE type = TYPE.fromTypeName(typeName);
if (TYPE.BALANCE.equals(type)) {
System.out.println("根据字符串获得的枚举类型实例跟枚举常量一致");
} else {
System.out.println("大师兄代码错误");
}
}
/**
* 季节枚举(不带参数的枚举常量)这个是最简单的枚举使用实例
* Ordinal 属性，对应的就是排列顺序，从0开始。
*/
private enum SimpleEnum {
SPRING,
SUMMER,
AUTUMN,
WINTER
}
/**
* 常用类型(带参数的枚举常量，这个只是在书上不常见，实际使用还是很多的，看懂这个，使用就不是问题啦。)
*/
private enum TYPE {
FIREWALL("firewall"),
SECRET("secretMac"),
BALANCE("f5");
private String typeName;
TYPE(String typeName) {
this.typeName = typeName;
}
/**
* 根据类型的名称，返回类型的枚举实例。
*
* @param typeName 类型名称
*/
public static TYPE fromTypeName(String typeName) {
for (TYPE type : TYPE.values()) {
if (type.getTypeName().equals(typeName)) {
return type;
}
}
return null;
}
public String getTypeName() {
return this.typeName;
}
}
}
运行结果：
简单的例子，大家基本都用过，看不懂的基本都是第二个例子。可以看到，在第二个例子里面，后面带有参数，其实可以这么理解。
enum这个关键字，可以理解为跟class差不多，这也个单独的类。可以看到，上面的例子里面有属性，有构造方法，有getter，也可以有setter，但是一般都是构造传参数。还有其他自定义方法。那么在这些东西前面的，以逗号隔开的，最后以分号结尾的，这部分叫做，这个枚举的实例。也可以理解为，class new 出来的实例对象。这下就好理解了。只是，class，new对象，可以自己随便new，想几个就几个，而这个enum关键字，他就不行，他的实例对象，只能在这个enum里面体现。也就是说，他对应的实例是有限的。这也就是枚举的好处了，限制了某些东西的范围，举个栗子：一年四季，只能有春夏秋冬，你要是字符串表示的话，那就海了去了，但是，要用枚举类型的话，你在enum的大括号里面把所有的选项，全列出来，那么这个季节的属性，对应的值，只能在里面挑。不能有其他的。
我上面的例子，就是根据typeName，你可以从那些例子里面挑选到唯一的一个TYPE类型的枚举实例--TYPE.BALANCE。注意方法
TYPE type = TYPE.fromTypeName(typeName);
这个方法的返回类型就是这个TYPE枚举类型的。
这下就好理解，这个枚举是怎么在工作了吧
再补充一下：
上面那个带参数的枚举类型的实例里面实际上是三个属性，除了我自定义的typeName以外，还有2个是系统自带的。看下面源码的图：
看到这里之后，不知道你能不能理解下面图片内说明的话：下面图片主要说明在使用枚举时，的规范和标准。希望可以在实际开发时候用到
最后补充一点：
也许你知道呢，但是也许你不知道呢？我是真的不知道，测了之后才知道！！！
枚举类型对象之间的值比较，是可以使用==，直接来比较值，是否相等的，不是必须使用equals方法的哟。
具体，请参考下面的链接：
2017.11.07 更新
有的老铁，说这个switch case怎么写，我就在下面再啰嗦一下。
private static void testSwitchCase() {
String typeName = "f5";
//这几行注释呢，你可以试着三选一，测试一下效果。
//String typeName = "firewall";
//String typeName = "secretMac";
TypeEnum typeEnum = TypeEnum.fromTypeName(typeName);
if (typeEnum == null) {
return;
}
switch (typeEnum) {
case FIREWALL:
System.out.println("枚举名称(即默认自带的属性 name 的值)是：" + typeEnum.name());
System.out.println("排序值(默认自带的属性 ordinal 的值)是：" + typeEnum.ordinal());
System.out.println("枚举的自定义属性 typeName 的值是：" + typeEnum.getTypeName());
break;
case SECRET:
System.out.println("枚举名称(即默认自带的属性 name 的值)是：" + typeEnum.name());
System.out.println("排序值(默认自带的属性 ordinal 的值)是：" + typeEnum.ordinal());
System.out.println("枚举的自定义属性 typeName 的值是：" + typeEnum.getTypeName());
break;
case BALANCE:
System.out.println("枚举名称(即默认自带的属性 name 的值)是：" + typeEnum.name());
System.out.println("排序值(默认自带的属性 ordinal 的值)是：" + typeEnum.ordinal());
System.out.println("枚举的自定义属性 typeName 的值是：" + typeEnum.getTypeName());
break;
default:
System.out.println("default");
}
}
然后，就是运行结果的截图。
老铁们，看完这个枚举，你要懂个概念，那就是，这个枚举，他是个对象，就像你定义的Student类，Person类，等等一些个类一样。
要有这么个概念。只要是个类，他就可以有构造函数，可以有属性，可以有方法。
对的，老铁，你对这个属性，构造函数啥的，有概念吧，没有的话，我可就郁闷啦。
然后，你就看到，这个地方有2个默认的属性，一个是name，一个是ordinal，这2个属性就像你定义Student类和Person类的name和age一样，
只不过，这2个是系统自带的属性，不用你自己去定义啦。
你也可以给这个枚举类，也就是你自己声明的枚举，随便加属性。
我上面代码例子里面的那个TypeEnum那个枚举，就是这么干的，就简单的添加了个自定义属性typeName，
虽然他有自己的name了，那姑且叫我这个自定义的属性叫别名吧。
可以看到，我例子里面就是通过自己写的那个构造方法给我这个自定义的属性初始化值的。
还有，这个构造方法是不可以，也不被运行public的，不信，你可以试试。
还有，你不能对系统自带的name属性，在构造函数里面赋值，没有为什么。
摘自：