Java枚举类型的用法
本文内容纲要：
-1.用法一:常量
-2.用法二：switch
-3.用法三：向枚举中添加新方法
-4.用法四：覆盖枚举的方法
-5.用法五：实现接口
-6.用法六：使用接口组织枚举
-7.用法七：关于枚举集合的使用
-1.EnumSet的简单用法
-2.EnumMap的简单用法
-补充:带抽象方法的枚举类型的应用
JDK1.5引入了新的类型——枚举。在Java中它虽然算个“小”功能，却给我的开发带来了“大”方便。
1.用法一:常量
在JDK1.5之前，我们定义常量都是：publicstaticfianl....(这种方式在现在项目中也很常见)。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。而且枚举类型可以帮助我们检测许多的编译失误。
例如:
packageenumTest;
publicenumColor{
RED,BLANK,YELLOW
}
测试代码:
packageenumTest;
publicclassTest{
publicstaticvoidmain(String[]args){
Stringstring=Color.BLANK.toString();
System.out.println(string);
System.out.println(Color.BLANK);
}
}
BLANK
BLANK
2.用法二：switch
JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。
publicstaticvoidmain(String[]args){
Colorcolor=Color.RED;
switch(color){
caseBLANK:
System.out.println("黑色");
break;
caseRED:
System.out.println("红色");
break;
default:
break;
}
}
结果:
红色
3.用法三：向枚举中添加新方法
如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且Java要求必须先定义enum实例。且枚举类型的构造方法必须为私有方法。
packageenumTest;
publicenumMyDay{
MONDAY(1,"星期一"),THUSDAY(2,"星期二");//这个后面必须有分号
privateintcode;
privateStringname;
privateMyDay(intcode,Stringname){
this.code=code;
this.name=name();
}
publicintgetCode(){
returncode;
}
publicStringgetName(){
returnname;
}
publicvoidsetCode(intcode){
this.code=code;
}
publicvoidsetName(Stringname){
this.name=name;
}
}
测试类:
publicstaticvoidmain(String[]args){
System.out.println(MyDay.MONDAY.getCode());
System.out.println(MyDay.MONDAY.getName());
System.out.println(MyDay.THUSDAY.getCode());
System.out.println(MyDay.THUSDAY.getName());
System.out.println(MyDay.THUSDAY);
}
结果:
1
MONDAY
2
THUSDAY
THUSDAY
注意:枚举类型中可以有静态方法，也可以与其他方法。可以有属性与get，set方法。
4.用法四：覆盖枚举的方法
例如:覆盖toString()方法
packageenumTest;
publicenumMyDay{
MONDAY(1,"星期一"),THUSDAY(2,"星期二");//这个后面必须有分号
privateintcode;
privateStringname;
privateMyDay(intcode,Stringname){
this.code=code;
this.name=name();
}
publicintgetCode(){
returncode;
}
publicStringgetName(){
returnname;
}
publicvoidsetCode(intcode){
this.code=code;
}
publicvoidsetName(Stringname){
this.name=name;
}
@Override
publicStringtoString(){
//TODOAuto-generatedmethodstub
returnthis.getName()+"---"+this.getCode();
}
}
测试:
packageenumTest;
publicclassTest{
publicstaticvoidmain(String[]args){
System.out.println(MyDay.MONDAY.getCode());
System.out.println(MyDay.MONDAY.getName());
System.out.println(MyDay.THUSDAY.getCode());
System.out.println(MyDay.THUSDAY.getName());
System.out.println(MyDay.THUSDAY);
}
}
结果:
1
MONDAY
2
THUSDAY
THUSDAY---2
利用javap反汇编查看编译好的class文件:继承自Enum类
$javap-cMyDay.class
Compiledfrom"MyDay.java"
publicfinalclassenumTest.MyDayextendsjava.lang.Enum<enumTest.MyDay>{
publicstaticfinalenumTest.MyDayMONDAY;
publicstaticfinalenumTest.MyDayTHUSDAY;
publicstaticenumTest.MyDay[]values();
Code:
0:getstatic#1//Field$VALUES:[LenumTest/MyDay;
3:invokevirtual#2//Method"[LenumTest/MyDay;".clone:()Ljava/lang/Object;
6:checkcast#3//class"[LenumTest/MyDay;"
9:areturn
publicstaticenumTest.MyDayvalueOf(java.lang.String);
Code:
0:ldc_w#4//classenumTest/MyDay
3:aload_0
4:invokestatic#5//Methodjava/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
7:checkcast#4//classenumTest/MyDay
10:areturn
publicintgetCode();
Code:
0:aload_0
1:getfield#7//Fieldcode:I
4:ireturn
publicjava.lang.StringgetName();
Code:
0:aload_0
1:getfield#9//Fieldname:Ljava/lang/String;
4:areturn
publicvoidsetCode(int);
Code:
0:aload_0
1:iload_1
2:putfield#7//Fieldcode:I
5:return
publicvoidsetName(java.lang.String);
Code:
0:aload_0
1:aload_1
2:putfield#9//Fieldname:Ljava/lang/String;
5:return
publicjava.lang.StringtoString();
Code:
0:new#10//classjava/lang/StringBuilder
3:dup
4:invokespecial#11//Methodjava/lang/StringBuilder."<init>":()V
7:aload_0
8:invokevirtual#12//MethodgetName:()Ljava/lang/String;
11:invokevirtual#13//Methodjava/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
14:ldc#14//String---
16:invokevirtual#13//Methodjava/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
19:aload_0
20:invokevirtual#15//MethodgetCode:()I
23:invokevirtual#16//Methodjava/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
26:invokevirtual#17//Methodjava/lang/StringBuilder.toString:()Ljava/lang/String;
29:areturn
static{};
Code:
0:new#4//classenumTest/MyDay
3:dup
4:ldc#18//StringMONDAY
6:iconst_0
7:iconst_1
8:ldc#19//String▒▒▒▒һ
10:invokespecial#20//Method"<init>":(Ljava/lang/String;IILjava/lang/String;)V
13:putstatic#21//FieldMONDAY:LenumTest/MyDay;
16:new#4//classenumTest/MyDay
19:dup
20:ldc#22//StringTHUSDAY
22:iconst_1
23:iconst_2
24:ldc#23//String▒▒▒ڶ▒
26:invokespecial#20//Method"<init>":(Ljava/lang/String;IILjava/lang/String;)V
29:putstatic#24//FieldTHUSDAY:LenumTest/MyDay;
32:iconst_2
33:anewarray#4//classenumTest/MyDay
36:dup
37:iconst_0
38:getstatic#21//FieldMONDAY:LenumTest/MyDay;
41:aastore
42:dup
43:iconst_1
44:getstatic#24//FieldTHUSDAY:LenumTest/MyDay;
47:aastore
48:putstatic#1//Field$VALUES:[LenumTest/MyDay;
51:return
}
可以看出枚举类的原理是将枚举类继承java.lang.Enum<enumTest.MyDay>，并且声明为final，其内部维护多个实例，而且是在静态代码块中进行实例化多个实例。其实普通的类构造方法声明为private，静态代码块中初始化对应的变量即可实现enum的原理代码。
5.用法五：实现接口
所有的枚举都继承自java.lang.Enum类。由于Java不支持多继承，所以枚举对象不能再继承其他类。
例如:
packageenumTest;
publicinterfaceDayInterface{
publicStringgetDay();
}
packageenumTest;
publicenumMyDayimplementsDayInterface{
MONDAY(1,"星期一"),THUSDAY(2,"星期二");//这个后面必须有分号
privateintcode;
privateStringname;
privateMyDay(intcode,Stringname){
this.code=code;
this.name=name();
}
publicintgetCode(){
returncode;
}
publicStringgetName(){
returnname;
}
publicvoidsetCode(intcode){
this.code=code;
}
publicvoidsetName(Stringname){
this.name=name;
}
@Override
publicStringtoString(){
//TODOAuto-generatedmethodstub
returnthis.getName()+"---"+this.getCode();
}
@Override
publicStringgetDay(){
returnthis.getName();
}
}
测试:
packageenumTest;
publicclassTest{
publicstaticvoidmain(String[]args){
System.out.println(MyDay.THUSDAY.getDay());
}
}
结果:
THUSDAY
6.用法六：使用接口组织枚举
packageenumTest;
publicinterfaceFood{
enumCoffeeimplementsFood{
BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO
}
enumDessertimplementsFood{
FRUIT,CAKE,GELATO
}
}
测试类:
packageenumTest;
importenumTest.Food.Coffee;
importenumTest.Food.Dessert;
publicclassTest{
publicstaticvoidmain(String[]args){
for(DessertdessertEnum:Food.Dessert.values()){
System.out.print(dessertEnum+"");
}
System.out.println();
//我这地方这么写，是因为我在自己测试的时候，把这个coffee单独到一个文件去实现那个food接口，而不是在那个接口的内部。
for(Coffeecoffee:Food.Coffee.values()){
System.out.print(coffee+"");
}
System.out.println();
//搞个实现接口，来组织枚举，简单讲，就是分类吧。如果大量使用枚举的话，这么干，在写代码的时候，就很方便调用啦。
//还有就是个“多态”的功能吧，
Foodfood=Food.Dessert.CAKE;
System.out.println(food);
food=Coffee.BLACK_COFFEE;
System.out.println(food);
}
}
结果:
FRUITCAKEGELATO
BLACK_COFFEEDECAF_COFFEELATTECAPPUCCINO
CAKE
BLACK_COFFEE
7.用法七：关于枚举集合的使用
java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的key是enum类型，而value则可以是任意类型。
1.EnumSet的简单用法
enumSet继承AbstractSet，AbstractSet实现了set接口。
publicabstractclassEnumSet<EextendsEnum<E>>extendsAbstractSet<E>
implementsCloneable,java.io.Serializable
{
。。。
}
publicabstractclassAbstractSet<E>extendsAbstractCollection<E>implementsSet<E>{
。。。
}
测试代码:
packageenumTest;
importjava.util.EnumSet;
importjava.util.Iterator;
publicclassTest{
publicstaticvoidmain(String[]args){
//创建一个EnumSet集合，其内部的值就是MyDay枚举类的实例
EnumSet<MyDay>enumSet=EnumSet.allOf(MyDay.class);
System.out.println(enumSet);
Iterator<MyDay>iterator=enumSet.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
//创建一个空的EnumSet集合
System.out.println("====================");
EnumSet<MyDay>enumSet2=EnumSet.noneOf(MyDay.class);
System.out.println(enumSet2);
enumSet2.add(MyDay.MONDAY);
System.out.println(enumSet2);
//创建一个带有指定值的EnumSet
System.out.println("====================");
EnumSet<MyDay>enumSet3=EnumSet.of(MyDay.MONDAY);
enumSet2.add(MyDay.MONDAY);//由于不可重复所以不会重复两个元素
System.out.println(enumSet3);
}
}
结果:
[MONDAY---1,THUSDAY---2]
MONDAY---1
THUSDAY---2
[]
[MONDAY---1]
[MONDAY---1]
2.EnumMap的简单用法
EnumMap继承AbstractMap，AbstractMap继承实现map接口。而且EnumMap中的中key必须为枚举类型，而且不能为null
publicclassEnumMap<KextendsEnum<K>,V>extendsAbstractMap<K,V>
implementsjava.io.Serializable,Cloneable
。。。
}
publicabstractclassAbstractMap<K,V>implementsMap<K,V>{
。。。
}
测试代码:
packageenumTest;
importjava.util.EnumMap;
importjava.util.HashMap;
importjava.util.Map;
publicclassTest{
publicstaticvoidmain(String[]args){
//创建一个空的map
EnumMap<MyDay,Object>enumMap=newEnumMap<>(MyDay.class);
System.out.println(enumMap);
enumMap.put(MyDay.MONDAY,"周一");
enumMap.put(MyDay.THUSDAY,"周四");
System.out.println(enumMap);
//创建第二个enumMap
EnumMap<MyDay,Object>enumMap2=newEnumMap<>(enumMap);
System.out.println(enumMap2);
//以普通map为参数创建第三个enumMap，要求key必须是枚举类型
Mapmap=newHashMap<>();
map.put(MyDay.MONDAY,111);
EnumMap<MyDay,Object>enumMap3=newEnumMap<>(map);
System.out.println(enumMap3);
}
}
结果：
{}
{MONDAY---1=周一,THUSDAY---2=周四}
{MONDAY---1=周一,THUSDAY---2=周四}
{MONDAY---1=111}
补充:
**1.枚举类型对象之间的值比较，是可以使用==，直接来比较值，是否相等的，不是必须使用equals方法的哟。**
publicstaticvoidmain(String[]args){
System.out.println(MyDay.MONDAY==MyDay.MONDAY);
System.out.println(MyDay.MONDAY==MyDay.MONDAY);
}
结果:
true
true
**2.我们大概了解了枚举类型的定义与简单使用后，现在有必要来了解一下枚举类型的基本实现原理。**
实际上在使用关键字enum创建枚举类型并编译后，编译器会为我们生成一个相关的类，这个类继承了JavaAPI中的java.lang.Enum类，也就是说通过关键字enum创建枚举类型在编译后事实上也是一个类类型而且该类继承自java.lang.Enum类。
C:\Users\liqiang\Desktop>javap-pMyDay.class
Compiledfrom"MyDay.java"
publicfinalclassMyDayextendsjava.lang.Enum<MyDay>{
publicstaticfinalMyDayMONDAY;
publicstaticfinalMyDayTHUSDAY;
privateintcode;
privatejava.lang.Stringname;
privatestaticfinalMyDay[]$VALUES;
publicstaticMyDay[]values();
publicstaticMyDayvalueOf(java.lang.String);
privateMyDay(int,java.lang.String);
publicintgetCode();
publicjava.lang.StringgetName();
publicvoidsetCode(int);
publicvoidsetName(java.lang.String);
static{};
}
**3.Enum抽象类常见方法**
Enum是所有Java语言枚举类型的公共基本类（注意Enum是抽象类），以下是它的常见方法：
| 方法说明 |
|---|
| 比较此枚举与指定对象的顺序 |
| 当指定对象等于此枚举常量时，返回true。 |
| 返回与此枚举常量的枚举类型相对应的Class对象 |
| 返回此枚举常量的名称，在其枚举声明中对其进行声明 |
| 返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零） |
| 返回枚举常量的名称，它包含在声明中 |
返回带指定名称的指定枚举类型的枚举常量。 |
这里主要说明一下ordinal()方法，该方法获取的是枚举变量在枚举类中声明的顺序，下标从0开始，如日期中的MONDAY在第一个位置，那么MONDAY的ordinal值就是0，如果MONDAY的声明位置发生变化，那么ordinal方法获取到的值也随之变化，注意在大多数情况下我们都不应该首先使用该方法，毕竟它总是变幻莫测的。compareTo(Eo)方法则是比较枚举的大小，注意其内部实现是根据每个枚举的ordinal值大小进行比较的。name()方法与toString()几乎是等同的，都是输出变量的字符串形式。至于valueOf(Class<T>enumType,Stringname)方法则是根据枚举类的Class对象和枚举名称获取枚举常量，注意该方法是静态的，后面在枚举单例时，我们还会详细分析该方法，下面的代码演示了上述方法：
**4.values()方法和valueOf(Stringname)方法是编译器生成的static方法****，**因此从前面的分析中，在Enum类中并没出现values()方法，但valueOf()方法还是有出现的，只不过编译器生成的valueOf()方法需传递一个name参数，而Enum自带的静态方法valueOf()则需要传递两个方法，从前面反编译后的代码可以看出，编译器生成的valueOf方法最终还是调用了Enum类的valueOf方法。
补充:带抽象方法的枚举类型的应用
如果我们写一个枚举类型来实现基本的运算，我们可能会写成下面:
publicenumOperation{
PLUS,MINUS,TIMES,DIVIDE;
publicdoubleoperate(doublenum1,doublenum2){
switch(this){
casePLUS:
returnnum1+num2;
caseMINUS:
returnnum1-num2;
caseTIMES:
returnnum1*num2;
caseDIVIDE:
returnnum1/num2;
}
thrownewRuntimeException("err");
}
}
如果我们增加一个新的运算规则需要增加一个新的实例，而且增加一个case分支。
用抽象方法+枚举替代:
publicenumOperation{
PLUS{
@Override
doubleoperate(doublenum1,doublenum2){
returnnum1+num2;
}
},
MINUS{
@Override
doubleoperate(doublenum1,doublenum2){
returnnum1-num2;
}
},
TIMES{
@Override
doubleoperate(doublenum1,doublenum2){
returnnum1*num2;
}
},
DIVIDE{
@Override
doubleoperate(doublenum1,doublenum2){
returnnum1/num2;
}
};
abstractdoubleoperate(doublenum1,doublenum2);
}
本文内容总结：1.用法一:常量，2.用法二：switch，3.用法三：向枚举中添加新方法，4.用法四：覆盖枚举的方法，5.用法五：实现接口，6.用法六：使用接口组织枚举，7.用法七：关于枚举集合的使用，1.EnumSet的简单用法，2.EnumMap的简单用法，补充:带抽象方法的枚举类型的应用，
原文链接：https://www.cnblogs.com/qlqwjy/p/9065264.html