JDK1.5引入了新的类型——枚举。在Java中它虽然算个“小”功能，却给我的开发带来了“大”方便。
在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
BLANKJDK1.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; } }结果:
红色
如果打算自定义自己的方法，那么必须在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方法。
例如:覆盖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的原理代码。
所有的枚举都继承自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
测试类:
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_COFFEEjava.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的key是enum类型，而value则可以是任意类型。
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]
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是抽象类），以下是它的常见方法：
返回类型 方法名称 int compareTo(Eo) boolean equals(Objectother) Class<?> getDeclaringClass() String name() int ordinal() String toString() static<TextendsEnum<T>>T staticvalueOf(Class<T>enumType,Stringname) 方法说明 比较此枚举与指定对象的顺序 当指定对象等于此枚举常量时，返回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相关推荐
数学中有许多类型的级数，可以在C编程中轻松解决。该程序是在C程序中找到系列后继的和。Tn = n2 - (n-1 2...
要从全部四列中找到最低分，请使用MySQLLEAST( 函数。让我们首先创建一个表-create table DemoTable( Score1 int,...
