首页 > 代码库 > Java核心 --- 枚举
Java核心 --- 枚举
Java核心 --- 枚举
枚举把显示的变量与逻辑的数字绑定在一起
在编译的时候，就会发现数据不合法
也起到了使程序更加易读，规范代码的作用
一、用普通类的方式实现枚举
新建一个终态类Season，把构造方法设为私有，因为枚举值不能随意增加
因为不能new出这个类的对象，所以需要定义成员变量，把new写在类的内部
这样，就可以在类的外部通过访问类的静态成员变量的方式访问到枚举值
通过这样的方式，只能在类的外部使用在枚举类的内部定义的枚举值
类Season里面是可以有方法的，我们设置地球又公转了四分之一
方法的返回值是Season，对应的这个类里面的所有枚举值将转动四分之一
重写方法toString()，打印枚举的值
测试一下，打印一个枚举值的next后的值，再经过toString后输出
/Enumeration/src/yuki/core/enumeration/imitation/SeasonTest.java
package yuki.core.enumeration.imitation;public class SeasonTest { public static void main(String[] args) { Season season = Season.AUTUMN; System.out.println(season.nextQuarter()); }}
/Enumeration/src/yuki/core/enumeration/imitation/Season.java
package yuki.core.enumeration.test;public final class Season { //私有构造方法 private Season(){} //定义静态成员常量 public final static Season SPRING = new Season(); public final static Season SUMMER = new Season(); public final static Season AUTUMN = new Season(); public final static Season WINTER = new Season(); //定义地球又公转了四分之一 public Season nextQuarter(){ Season ret = null; if(this == WINTER) ret = SPRING; else if(this == SPRING) ret = SUMMER; else if(this == SUMMER) ret = AUTUMN; else if(this == AUTUMN) ret = WINTER; return ret; } //打印枚举的值 @Override public String toString(){ return this == WINTER ? "Winter" : ( this == SPRING ? "Spring" : ( this == SUMMER ? "Summer" : "Autumn")); } }
可以看到程序中出现了大量的if-else，这样似乎不太好
可以把每一个元素的nextQuarter写成自己独立的方法
这需要定义成抽象的nextQuarter来使要新建对象就必须先实现这个方法
拥有抽象方法的类也必须是抽象的
这时，直接使用new来新建对象的方式就会报红，使用它的子类创建实例对象
定义为抽象的类需要子类来实现它的抽象方法，这是需要去掉final修饰符
在每个枚举值得类中实现抽象方法nextQuarter()，再次测试
在这里，把统一的if-else语句转化为了一个个独立的类
/Enumeration/src/yuki/core/enumeration/imitation/Season.java
package yuki.core.enumeration.imitation;public abstract class Season { //私有构造方法 private Season(){} //定义静态成员常量 public final static Season SPRING = new Season(){ @Override public Season nextQuarter() { return SUMMER; } }; public final static Season SUMMER = new Season(){ @Override public Season nextQuarter() { return AUTUMN; } }; public final static Season AUTUMN = new Season(){ @Override public Season nextQuarter() { return WINTER; } }; public final static Season WINTER = new Season(){ @Override public Season nextQuarter() { return SPRING; } }; public abstract Season nextQuarter(); //打印枚举的值 @Override public String toString(){ return this == WINTER ? "Winter" : ( this == SPRING ? "Spring" : ( this == SUMMER ? "Summer" : "Autumn")); } }
运行结果如下：
Winter
二、一个基本的枚举类
这里把枚举放在类里定义，作为测试类的一个成员内部类
枚举里的一个元素就相当于类里的一个对象
对于枚举这种类型的对象，它自动的帮我们实现了toString方法
打印出的是枚举值的接收引用的名称
方法name()获得接收引用的名称
方法ordinal()获得枚举值在枚举中所在的位置，下表从0开始
静态方法valueOf(String)可以通过枚举值的名称得到枚举值
从浏览器获得的请求参数值就可以通过这种方式编程枚举值对象
静态方法values()可以获得枚举里的所有枚举值
/Enumeration/src/yuki/core/enumeration/construction/SquareVertexTest.java
package yuki.core.enumeration.construction;public class SquareVertexTest { public static void main(String[] args) { SquareVertex vertex = SquareVertex.A; System.out.println(vertex); System.out.println(vertex.name()); System.out.println(vertex.ordinal()); System.out.println(SquareVertex.valueOf("D")); System.out.println(SquareVertex.values().length); } /** * 正方形的四个顶点 */ public enum SquareVertex{ A, B, C, D }}
运行结果如下：
AA0D4
三、带有构造方法的枚举
枚举是一个类，所以应该可以定义自己的构造方法
构造方法必须放在元素列表之后，并在元素列表之后加上分号
构造方法必须是私有的，默认调用的是无参构造
所有的枚举值在第一次用到枚举类时全部初始化
在枚举元素后加圆括号指定参数列表，可以调用对应的构造方法
在枚举元素后加上没有内容的圆括号，调用的方法也是无参构造方法
/Enumeration/src/yuki/core/enumeration/construction/DirectionTest.java
package yuki.core.enumeration.construction;public class DirectionTest { public static void main(String[] args) { @SuppressWarnings("unused") Direction direction = Direction.W; } public enum Direction{ E(1), S(), W, N; private Direction(){ System.out.println("无参构造方法"); } private Direction(int direct){ System.out.println("Direction(int direct)"); } }}
运行结果如下：
Direction(int direct)无参构造方法无参构造方法无参构造方法
四、实现带有抽象方法的枚举
添加一个抽象方法返回类型是枚举类本身
在枚举元素后添加花括号实现这个抽象方法
/Enumeration/src/yuki/core/enumeration/abstraction/ColorTest.java
package yuki.core.enumeration.abstraction;public class ColorTest { public static void main(String[] args) { } public enum TrafficLamp{ RED{ @Override public TrafficLamp nextLamp() { return GREEN; } }, GREEN{ @Override public TrafficLamp nextLamp() { return YELLOW; } }, YELLOW{ @Override public TrafficLamp nextLamp() { return RED; } }; public abstract TrafficLamp nextLamp(); }}
在bin目录下可以看到枚举的每个元素都生成了class文件
D:\Workspaces\Eclipse\Enumeration\bin\yuki\core\enumeration\abstraction
为灯指定一个时间，这时需要在枚举元素的后面加上构造参数
/Enumeration/src/yuki/core/enumeration/abstraction/LampTest.java
package yuki.core.enumeration.abstraction;public class LampTest { public static void main(String[] args) { } public enum TrafficLamp{ RED(30){ @Override public TrafficLamp nextLamp() { return GREEN; } }, GREEN(45){ @Override public TrafficLamp nextLamp() { return YELLOW; } }, YELLOW(5){ @Override public TrafficLamp nextLamp() { return RED; } }; public abstract TrafficLamp nextLamp(); @SuppressWarnings("unused") private int time; private TrafficLamp(int time){ this.time = time; } }}
在新建父类的匿名子类对象时，可以指定调用父类的构造方法
/Enumeration/src/yuki/core/enumeration/abstraction/ConstructorTest.java
package yuki.core.enumeration.abstraction;public class ConstructorTest { public static void main(String[] args) { Supper supper = new Supper(1234){ @Override public String toString(){ return "子类的toString方法"; } }; System.out.println(supper); } public static class Supper{ public Supper() { System.out.println("无参构造被调用"); } public Supper(int i){ System.out.println("有参构造被调用"); } }}
运行结果如下：
有参构造被调用子类的toString方法如果枚举只有一个成员，可以作为一种单例模式的实现方式
更多内容请参考：[张孝祥Java高新技术_枚举]
五、为枚举提供的功能和演示
1. 枚举与switch-case
switch中匹配枚举值时，只需要写出不带枚举类型的枚举值就可以了
/Enumeration/src/yuki/core/enumeration/switch_case/QuarkTest.java
package yuki.core.enumeration.switch_case;public class QuarkTest { public static void main(String[] args) { Quark quark = Quark.C; String name = null; switch(quark){ case U: name = "上夸克"; break; case D: name = "下夸克"; break; case C: name = "粲夸克"; break; case S: name = "奇夸克"; break; case T: name = "顶夸克"; break; case B: name = "底夸克"; break; } System.out.println(name); } private enum Quark{ U, D, C, S, T, B; }}
运行结果如下：
粲夸克
2. 定制自己的枚举字符串
这样就可以不用public static final String variable_name = string_value;
/Enumeration/src/yuki/core/enumeration/const_string/WebsiteTest.java
package yuki.core.enumeration.const_string;public class WebsiteTest { private enum Website{ GOOGLE("https://www.google.com.hk/?gws_rd=ssl"), AMAZON("http://www.amazon.cn/"); //网址 private String address; //构造函数 private Website(String address){ this.address = address; } //获取地址的方法 public String address() { return address; } } public static void main(String[] args) { Website amazon = Website.AMAZON; System.out.println(amazon); System.out.println(amazon.address()); }}
运行结果如下：
AMAZONhttp://www.amazon.cn/
3. EnumSet和EnumMap
JDK5.0 中在增加 Enum 类的同时，也增加了两个工具类 EnumSet 和 EnumMap，
这两个类都放在 java.util 包中。
/Enumeration/src/yuki/core/enumeration/enum_util/EnumSetTest.java
package yuki.core.enumeration.enum_util;import java.util.EnumSet;/** * JDK5.0 中在增加 Enum 类的同时，也增加了两个工具类 EnumSet 和 EnumMap， * 这两个类都放在 java.util 包中。 * * EnumSet 是一个针对枚举类型的高性能的 Set 接口实现。 * EnumSet 中装入的所有枚举对象都必须是同一种类型， * 在其内部，是通过bit-vector 来实现，也就是通过一个 long 型数。 * EnumSet 支持在枚举类型的所有值的某个范围中进行迭代。 * * @author yuki * */public class EnumSetTest { private enum WeekDay{ Mon, Tue, Wed, Thu, Fri, Sat, Sun; } public static void main(String[] args) {// EnumSet<WeekDay> weekDays = EnumSet.of(WeekDay.Fri, WeekDay.Tue); EnumSet<WeekDay> weekDays = EnumSet.range(WeekDay.Tue, WeekDay.Fri); for(WeekDay day : weekDays){ System.out.println(day); } } }
运行结果如下：
TueWedThuFri/Enumeration/src/yuki/core/enumeration/enum_util/EnumMapTest.java
package yuki.core.enumeration.enum_util;import java.util.EnumMap;import java.util.Map;/** * 与EnumSet 类似，EnumMap 也是一个高性能的 Map 接口实现， * 用来管理使用枚举类型作为 keys 的映射表，内部是通过数组方式来实现。 * EnumMap 将丰富的和安全的 Map 接口与数组快速访问结合到一起， * 如果你希望要将一个枚举类型映射到一个值，你应该使用 EnumMap。 * * @author yuki * */public class EnumMapTest { //卦值 private enum Divination{ KAN, XUN, QIAN, DUI, LI, ZHENG, KUN, GEN } //自然值 private enum Nature{ SHUI, FENG, TIAN, ZE, HUO, LEI, DI, SHAN } public static void main(String[] args) { //将卦值与自然值对应起来 Map<Divination, Nature> schema = new EnumMap<>(Divination.class); for(int i = 0; i < Divination.values().length; ++i){ schema.put(Divination.values()[i], Nature.values()[i]); } for(Map.Entry<Divination, Nature> entry : schema.entrySet()){ System.out.println(entry.getKey() + "\t->\t" + entry.getValue()); } }}
运行结果如下：
KAN -> SHUIXUN -> FENGQIAN -> TIANDUI -> ZELI -> HUOZHENG -> LEIKUN -> DIGEN -> SHAN
更多疑问请参考：[Java 语言中 Enum 类型的使用介绍]：
http://www.ibm.com/developerworks/cn/java/j-lo-enum/index.html
六、反编译工具jdecompiler
下载地址：http://jd.benow.ca/ ，点击下载JD-Eclipse>Offline installation
按照提示的步骤安装，把下载文件解压到以压缩包名为文件名的文件夹
Help>InstallNewSoftware...>Add>AddRepository>选择文件夹jdeclipse_update_site
Name=jdeclipse; Location=C:\Users\yuki\Downloads\jdeclipse_update_site
点击OK，列表中出现Java Decompiler Eclipse Plug-in>勾选它>Next
这时鼠标的指针变为等待，显示Calculating requirements and dependencies
额，这好像要等好久，我去吃饭了，~~，哦，只是前面慢而已，点击Next
选择I accept the terms of the license agreement>Finish
显示InstallSoftware的弹出窗，这里又好慢
再按照提示添加EmmanuelDupuy>选中>Finish>安装完成>restart Eclipse
打开Perferences>Java>Decompile，表明已经安装成功，
当然下载的svn也是上面格式的文件，所以应该也可以用上面的方式安装
General>Editor>FileAssociation>点击*.class without source
看到默认是用ClassFileEditor打开的，从它的图标不难看出，
它就是把class文件反编译为java文件格式打开的编辑器
在很多情况下我们是有源码的，当源码在maven库中对应的位置时
maven工具就会自动下载源码，并用ClassFileViewer打开
在设为默认后，重新打开Eclipse会发现默认的class打开方式还是反编译打开
点击General>StartupAndShutdown，这里有一个检查项JD-Eclipse Plug-in
取消它的勾选就可以了
七、反编译枚举类的类文件
bin目录下的内容按照Eclipse的设定是不显示的
在src下的class文件也是默认不显示的
写一个枚举类PlatonicSolid，里面有五种元素
package yuki.core.enumeration.decompiler;public enum PlatonicSolid { FOUR, EIGHT, TWENTY, SIX, TWELVE}
打开\Enumeration\bin\yuki\core\enumeration\decompiler\
复制PlatonicSolid.class到根目录下
打开后，文件以为自己是有源码的，所以这里反编译不起作用
访问http://jd.benow.ca/ 下载JD-GUI，
证明这个反编译器打不开编译后的枚举类文件
额，不是要下载右边那个，左边那个是稳定版
打开后反编译的结果就仅仅是源码去掉了注释
看起来软件升级了，看不到想要看的内容了
反编译网站：http://www.findmaven.net/decompile ，同样的结果
反编译网站：http://www.showmycode.com/ 反编译结果如下
经过我的排板后的文件如下：因为编译不通过，所以用Ctrl+Shift+F排版是不行的
/Enumeration/src/yuki/core/enumeration/decompiler/platonic_solid/PlatonicSolid.java
package yuki.core.enumeration.decompiler.platonic_solid;public final class PlatonicSolid extends Enum<Enum<E>> { private PlatonicSolid(String s, int i) { super(s, i); } public static PlatonicSolid[] values() { PlatonicSolid aplatonicsolid[]; int i; PlatonicSolid aplatonicsolid1[]; System.arraycopy(aplatonicsolid = enum$VALUES, 0, aplatonicsolid1 = new PlatonicSolid[i = aplatonicsolid.length], 0, i); return aplatonicsolid1; } public static PlatonicSolid valueOf(String s) { return (PlatonicSolid)enum.valueOf(yuki/core/enumeration/decompiler/PlatonicSolid, s); } public static final PlatonicSolid FOUR; public static final PlatonicSolid EIGHT; public static final PlatonicSolid TWENTY; public static final PlatonicSolid SIX; public static final PlatonicSolid TWELVE; private static final PlatonicSolid enum$VALUES[]; static { FOUR = new PlatonicSolid("FOUR", 0); EIGHT = new PlatonicSolid("EIGHT", 1); TWENTY = new PlatonicSolid("TWENTY", 2); SIX = new PlatonicSolid("SIX", 3); TWELVE = new PlatonicSolid("TWELVE", 4); enum$VALUES = (new PlatonicSolid[] { FOUR, EIGHT, TWENTY, SIX, TWELVE }); }}
但是Enum是无法被继承的，具体请见：
http://www.zhihu.com/question/19908744
http://pf-miles.iteye.com/blog/187155
后一篇文章所说的内容就是，枚举的多态是由属性的类继承枚举类实现的
枚举类的声明如下：
public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable
这里的E继承了Enum<E>， 而枚举E又是枚举类的泛型参数，如果可以继承
public final class PlatonicSolid extends Enum<Enum<E>>
那么就必须要拥有一个继承了枚举的枚举类，
这又回到了刚才的问题，所以问题无解
八、构造方法，方法，变量
枚举类型的每一个值都将映射到protected Enum(String name, int ordinal)构造函数中
在这里，每个值的名称都被转换成一个字符串，并且序数设置表示了每个设置的优先值。
换句话说，enum Size {Small, Medium, Large} 将映射到清单 2 中所示的构造函数调用中：
new Enum<Size>("Small", 0);
new Enum<Size>("Medium", 1);
new Enum<Size>("Large", 2);
更多疑问请参考：[驯服 Tiger: 深入研究枚举类型]：
http://www.ibm.com/developerworks/cn/java/j-tiger04195/
九、实现接口与使用接口组织枚举
所有的枚举都继承自java.lang.Enum类。
由于Java 不支持多继承，所以枚举对象不能再继承其他类。
/Enumeration/src/yuki/core/enumeration/interfaces/PlanetTest.java
package yuki.core.enumeration.interfaces;import java.util.Arrays;import java.util.List;public class PlanetTest { private interface Move{ void move(); }; private enum Planet implements Move{ SOLAR, EARTH{ @Override public void move() { System.out.println("rounding...center:" + SOLAR); } }, MOON{ @Override public void move() { System.out.println("rounding...center:" + EARTH); } }; @Override public void move() { System.out.println("rounding..."); } } public static void main(String[] args) { List<Planet> planets = Arrays.asList(Planet.values()); for(Planet planet : planets){ System.out.print(planet + " : "); planet.move(); } }}
运行结果如下：
SOLAR : rounding...EARTH : rounding...center:SOLARMOON : rounding...center:EARTH
使用接口也可以管理枚举，并且可以在接口内部再定义接口
/Enumeration/src/yuki/core/enumeration/interfaces/Shape.java
package yuki.core.enumeration.interfaces;public interface Shape { enum Circle implements Shape { Center, Radius } interface RegularPolygon extends Shape { enum Triangle implements RegularPolygon { Angel, Length } enum Square implements RegularPolygon { Point, Area } }}
/Enumeration/src/yuki/core/enumeration/interfaces/ShapeTest.java
package yuki.core.enumeration.interfaces;public class ShapeTest { public static void main(String[] args) { Shape circle = Shape.Circle.Radius; System.out.println(circle); Shape squre = Shape.RegularPolygon.Square.Area; System.out.println(squre); }}
运行结果如下：
RadiusArea更多疑问请参考：[Java 枚举7常见种用法]：
http://softbeta.iteye.com/blog/1185573
http://www.cnblogs.com/happyPawpaw/archive/2013/04/09/3009553.html
更多好文请查看：http://www.cnblogs.com/kodoyang/
点击下方的红色按钮“ 关注我 ”吧！
孔东阳
2014/10/2
Java核心 --- 枚举