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 } }
运行结果如下:
A A 0 D 4
三、带有构造方法的枚举
枚举是一个类,所以应该可以定义自己的构造方法
构造方法必须放在元素列表之后,并在元素列表之后加上分号
构造方法必须是私有的,默认调用的是无参构造
所有的枚举值在第一次用到枚举类时全部初始化
在枚举元素后加圆括号指定参数列表,可以调用对应的构造方法
在枚举元素后加上没有内容的圆括号,调用的方法也是无参构造方法
/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()); } }
运行结果如下:
AMAZON http://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); } } }
运行结果如下:
Tue Wed Thu Fri
/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 -> SHUI XUN -> FENG QIAN -> TIAN DUI -> ZE LI -> HUO ZHENG -> LEI KUN -> DI GEN -> 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:SOLAR MOON : 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); } }
运行结果如下:
Radius Area
更多疑问请参考:[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核心 --- 枚举的更多相关文章
-
Java核心 --- 注解
Java核心——注解 注解是jdk5以后的新特性,Spring和Hibernate等框架提供了注解的配置方式使用, 本文参考了浪曦风中叶的注解讲解,主要讲解jdk内置注解的用法,注解的声明和定义,以及 ...
-
Java核心编程快速学习
Java核心编程部分的基础学习内容就不一一介绍了,本文的重点是JAVA中相对复杂的一些概念,主体内容如下图所示. 反射reflect是理解Java语言工作原理的基础,Java编译器首先需要将我们编写的 ...
-
Java核心编程快速入门
Java核心编程部分的基础学习内容就不一一介绍了,本文的重点是JAVA中相对复杂的一些概念,主体内容如下图所示. 反射reflect是理解Java语言工作原理的基础,Java编译器首先需要将我们编写的 ...
-
Java核心编程快速学习(转载)
http://www.cnblogs.com/wanliwang01/p/java_core.html Java核心编程部分的基础学习内容就不一一介绍了,本文的重点是JAVA中相对复杂的一些概念,主体 ...
-
万字长文,62道Java核心面试题,一次性打包送给积极向上的你
先看再点赞,给自己一点思考的时间,微信搜索[沉默王二]关注这个靠才华苟且的程序员.本文 GitHub github.com/itwanger 已收录,里面还有一线大厂整理的面试题,以及我的系列文章. ...
-
Java核心类
Java核心类的学习: 常用类库 io流 集合 多线程 网络编程 调试与优化 XML和JSON 枚举.注解和反射 设计模式
-
深入Java核心 Java中多态的实现机制(1)
在疯狂java中,多态是这样解释的: 多态:相同类型的变量,调用同一个方法时,呈现出多中不同的行为特征, 这就是多态. 加上下面的解释:(多态四小类:强制的,重载的,参数的和包含的) 同时, 还用人这 ...
-
Java核心:类加载和JVM内存的分配
类的加载: 指的是将class文件的二进制数据读入到运行时数据区(JVM在内存中划分的) 中,并在方法区内创建一个class对象. 类加载器: 负责加载编译后的class文件(字节码文件)到JVM(J ...
-
深入Java核心 Java内存分配原理精讲
深入Java核心 Java内存分配原理精讲 栈.堆.常量池虽同属Java内存分配时操作的区域,但其适用范围和功用却大不相同.本文将深入Java核心,详细讲解Java内存分配方面的知识. Java内存分 ...
随机推荐
-
JavaScript如何使用this
学习this的使用必须牢记以下两点 1.this是一个只能在函数内部使用的关键字 2.this指向调用函数的那个对象 下面我们来具体讨论一下this的具体使用方法 第一种:通过函数调用的方式----- ...
-
MongoDB常用操作总结
====================================MGDB的操作====================================== 0.创建数据库时使用(use 数据库 ...
-
Javascript操纵Cookie--转
引用地址:http://www.imkevinyang.com/2009/06/javascript%E6%93%8D%E7%BA%B5cookie.html 在讲如何使用Javascript操纵Co ...
-
jQuery鼠标事件
鼠标事件是在用户移动鼠标光标或者使用任意鼠标键点击时触发的. (1):click事件:click事件于用户在元素敲击鼠标左键,并在相同元素上松开左键时触发. $('p').click ...
-
同时存在两个或多个homestead 虚拟box
开发中发现,不同版本的homestead 里面的环境各不相同,里面的node,npm等版本都不一致,如果需要添加 不同版本的homestead同时存在可以按照以下办法处理. tips: 提供可以离线下 ...
-
mysql-connector-python
wget http://cdn.mysql.com//Downloads/Connector-Python/mysql-connector-python-2.1.3.tar.gz tar mysql- ...
-
JPA字段映射(uuid,日期,枚举,@Lob)
转:http://www.cnblogs.com/tazi/archive/2012/01/04/2311588.html 主键: JPA主键的生成策略不像Hibernate那么丰富. @Id @Ge ...
-
【3】python核心编程 第五章-数字
1.用大写字母 “L”表示长整数 尽管 Python 也支持用小写字母 L 标记的长整型,但是我们郑重推荐您仅使用大写的 “L”, 这样能有效避免数字1 和小写L 的混淆.Python 在显示长整数类 ...
-
MyBatis3系列__02接口式编程
hello world MyBatis3支持面向接口编程: 具体做法如下,将helloWorld中的EmployeeMapper.xml文件进行更改: <?xml version="1 ...
-
聊聊阿里社招面试,谈谈“野生”Java程序员学习的道路
引言 很尴尬的是,这个类型的文章其实之前笔者就写过,原文章里,笔者自称LZ(也就是楼主,有人说是老子的简写,笔者只想说,这位同学你站出来,保证不打死你,-_-),原文章名称叫做<回答阿里社招面试 ...