JDK1.5引入了新的类型——枚举。在 Java 中它虽然算个“小”功能,却给我的开发带来了“大”方便。

1.用法一:常量

  在JDK1.5 之前,我们定义常量都是: public static fianl....(这种方式在现在项目中也很常见) 。现在好了,有了枚举,可以把相关的常量分组到一个枚举类型里,而且枚举提供了比常量更多的方法。而且枚举类型可以帮助我们检测许多的编译失误。

例如:

package enumTest;

public enum Color {
RED,BLANK,YELLOW
}

测试代码:

package enumTest;

public class Test {
public static void main(String[] args) {
String string = Color.BLANK.toString();
System.out.println(string);
System.out.println(Color.BLANK);
}
}

BLANK
BLANK

2.用法二:switch

  JDK1.6之前的switch语句只支持int,char,enum类型,使用枚举,能让我们的代码可读性更强。

    public static void main(String[] args) {
Color color = Color.RED;
switch (color) {
case BLANK:
System.out.println("黑色");
break;
case RED:
System.out.println("红色");
break;
default:
break;
}
}

结果:

  红色

3.用法三:向枚举中添加新方法

  如果打算自定义自己的方法,那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。 且枚举类型的构造方法必须为私有方法。

package enumTest;

public enum MyDay {

    MONDAY(1,"星期一"),THUSDAY(2,"星期二");//这个后面必须有分号

    private int code;
private String name;
private MyDay(int code,String name) {
this.code = code;
this.name = name();
} public int getCode() {
return code;
}
public String getName() {
return name;
}
public void setCode(int code) {
this.code = code;
}
public void setName(String name) {
this.name = name;
} }

测试类:

    public static void main(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()方法

package enumTest;

public enum MyDay {

    MONDAY(1,"星期一"),THUSDAY(2,"星期二");//这个后面必须有分号

    private int code;
private String name;
private MyDay(int code,String name) {
this.code = code;
this.name = name();
} public int getCode() {
return code;
}
public String getName() {
return name;
}
public void setCode(int code) {
this.code = code;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return this.getName()+"---"+this.getCode();
}
}

测试:

package enumTest;

public class Test {
public static void main(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 -c MyDay.class
Compiled from "MyDay.java"
public final class enumTest.MyDay extends java.lang.Enum<enumTest.MyDay> {
public static final enumTest.MyDay MONDAY; public static final enumTest.MyDay THUSDAY; public static enumTest.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 public static enumTest.MyDay valueOf(java.lang.String);
Code:
0: ldc_w #4 // class enumTest/MyDay
3: aload_0
4: invokestatic #5 // Method java/lang/Enum.valueOf:(Lj ava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
7: checkcast #4 // class enumTest/MyDay
10: areturn public int getCode();
Code:
0: aload_0
1: getfield #7 // Field code:I
4: ireturn public java.lang.String getName();
Code:
0: aload_0
1: getfield #9 // Field name:Ljava/lang/String;
4: areturn public void setCode(int);
Code:
0: aload_0
1: iload_1
2: putfield #7 // Field code:I
5: return public void setName(java.lang.String);
Code:
0: aload_0
1: aload_1
2: putfield #9 // Field name:Ljava/lang/String;
5: return public java.lang.String toString();
Code:
0: new #10 // class java/lang/StringBuilder
3: dup
4: invokespecial #11 // Method java/lang/StringBuilder."< init>":()V
7: aload_0
8: invokevirtual #12 // Method getName:()Ljava/lang/Strin g;
11: invokevirtual #13 // Method java/lang/StringBuilder.ap pend:(Ljava/lang/String;)Ljava/lang/StringBuilder;
14: ldc #14 // String ---
16: invokevirtual #13 // Method java/lang/StringBuilder.ap pend:(Ljava/lang/String;)Ljava/lang/StringBuilder;
19: aload_0
20: invokevirtual #15 // Method getCode:()I
23: invokevirtual #16 // Method java/lang/StringBuilder.ap pend:(I)Ljava/lang/StringBuilder;
26: invokevirtual #17 // Method java/lang/StringBuilder.to String:()Ljava/lang/String;
29: areturn static {};
Code:
0: new #4 // class enumTest/MyDay
3: dup
4: ldc #18 // String MONDAY
6: iconst_0
7: iconst_1
8: ldc #19 // String ▒▒▒▒һ
10: invokespecial #20 // Method "<init>":(Ljava/lang/Strin g;IILjava/lang/String;)V
13: putstatic #21 // Field MONDAY:LenumTest/MyDay;
16: new #4 // class enumTest/MyDay
19: dup
20: ldc #22 // String THUSDAY
22: iconst_1
23: iconst_2
24: ldc #23 // String ▒▒▒ڶ▒
26: invokespecial #20 // Method "<init>":(Ljava/lang/Strin g;IILjava/lang/String;)V
29: putstatic #24 // Field THUSDAY:LenumTest/MyDay;
32: iconst_2
33: anewarray #4 // class enumTest/MyDay
36: dup
37: iconst_0
38: getstatic #21 // Field MONDAY:LenumTest/MyDay;
41: aastore
42: dup
43: iconst_1
44: getstatic #24 // Field THUSDAY: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 不支持多继承,所以枚举对象不能再继承其他类。

例如:

package enumTest;

public interface DayInterface {

    public String getDay();
}
package enumTest;

public enum MyDay implements DayInterface{

    MONDAY(1,"星期一"),THUSDAY(2,"星期二");//这个后面必须有分号

    private int code;
private String name;
private MyDay(int code,String name) {
this.code = code;
this.name = name();
} public int getCode() {
return code;
}
public String getName() {
return name;
}
public void setCode(int code) {
this.code = code;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return this.getName()+"---"+this.getCode();
} @Override
public String getDay() {
return this.getName();
}
}

测试:

package enumTest;

public class Test {
public static void main(String[] args) {
System.out.println(MyDay.THUSDAY.getDay());
}
}

结果:

THUSDAY

6.用法六:使用接口组织枚举

package enumTest;

public interface Food {
enum Coffee implements Food{
BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO
}
enum Dessert implements Food{
FRUIT, CAKE, GELATO
}
}

测试类:

package enumTest;

import enumTest.Food.Coffee;
import enumTest.Food.Dessert; public class Test { public static void main(String[] args) {
for (Dessert dessertEnum : Food.Dessert.values()) {
System.out.print(dessertEnum + " ");
}
System.out.println();
//我这地方这么写,是因为我在自己测试的时候,把这个coffee单独到一个文件去实现那个food接口,而不是在那个接口的内部。
for (Coffee coffee : Food.Coffee.values()) {
System.out.print(coffee + " ");
}
System.out.println();
//搞个实现接口,来组织枚举,简单讲,就是分类吧。如果大量使用枚举的话,这么干,在写代码的时候,就很方便调用啦。
//还有就是个“多态”的功能吧,
Food food = Food.Dessert.CAKE;
System.out.println(food);
food = Coffee.BLACK_COFFEE;
System.out.println(food);
}
}

结果:

FRUIT CAKE GELATO
BLACK_COFFEE DECAF_COFFEE LATTE CAPPUCCINO
CAKE
BLACK_COFFEE

7.用法七:关于枚举集合的使用

  java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复;EnumMap中的 key是enum类型,而value则可以是任意类型。

1. EnumSet的简单用法

  enumSet继承AbstractSet,AbstractSet实现了set接口。

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>
implements Cloneable, java.io.Serializable
{
。。。
} public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> {
。。。
}

测试代码:

package enumTest;

import java.util.EnumSet;
import java.util.Iterator; public class Test {
public static void main(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

public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V>
implements java.io.Serializable, Cloneable
。。。
} public abstract class AbstractMap<K,V> implements Map<K,V> {
。。。
}

测试代码:

package enumTest;

import java.util.EnumMap;
import java.util.HashMap;
import java.util.Map; public class Test {
public static void main(String[] args) {
// 创建一个空的map
EnumMap<MyDay, Object> enumMap = new EnumMap<>(MyDay.class);
System.out.println(enumMap);
enumMap.put(MyDay.MONDAY, "周一");
enumMap.put(MyDay.THUSDAY, "周四");
System.out.println(enumMap); // 创建第二个enumMap
EnumMap<MyDay, Object> enumMap2 = new EnumMap<>(enumMap);
System.out.println(enumMap2); // 以普通map为参数创建第三个enumMap,要求key必须是枚举类型
Map map = new HashMap<>();
map.put(MyDay.MONDAY, 111);
EnumMap<MyDay, Object> enumMap3 = new EnumMap<>(map);
System.out.println(enumMap3);
}
}

结果:

{}
{MONDAY---1=周一, THUSDAY---2=周四}
{MONDAY---1=周一, THUSDAY---2=周四}
{MONDAY---1=111}

补充:

  1.枚举类型对象之间的值比较,是可以使用==,直接来比较值,是否相等的,不是必须使用equals方法的哟。

    public  static void main(String[] args) {
System.out.println(MyDay.MONDAY == MyDay.MONDAY);
System.out.println(MyDay.MONDAY == MyDay.MONDAY);
}

结果:

true
true

  2.我们大概了解了枚举类型的定义与简单使用后,现在有必要来了解一下枚举类型的基本实现原理。

  实际上在使用关键字enum创建枚举类型并编译后,编译器会为我们生成一个相关的类,这个类继承了Java API中的java.lang.Enum类,也就是说通过关键字enum创建枚举类型在编译后事实上也是一个类类型而且该类继承自java.lang.Enum类。

C:\Users\liqiang\Desktop>javap -p MyDay.class
Compiled from "MyDay.java"
public final class MyDay extends java.lang.Enum<MyDay> {
public static final MyDay MONDAY;
public static final MyDay THUSDAY;
private int code;
private java.lang.String name;
private static final MyDay[] $VALUES;
public static MyDay[] values();
public static MyDay valueOf(java.lang.String);
private MyDay(int, java.lang.String);
public int getCode();
public java.lang.String getName();
public void setCode(int);
public void setName(java.lang.String);
static {};
}

  3.Enum抽象类常见方法

Enum是所有 Java 语言枚举类型的公共基本类(注意Enum是抽象类),以下是它的常见方法:

返回类型 方法名称 方法说明
int compareTo(E o) 比较此枚举与指定对象的顺序
boolean equals(Object other) 当指定对象等于此枚举常量时,返回 true。
Class<?> getDeclaringClass() 返回与此枚举常量的枚举类型相对应的 Class 对象
String name() 返回此枚举常量的名称,在其枚举声明中对其进行声明
int ordinal() 返回枚举常量的序数(它在枚举声明中的位置,其中初始常量序数为零)
String toString() 返回枚举常量的名称,它包含在声明中
static<T extends Enum<T>> T static valueOf(Class<T> enumType, String name) 返回带指定名称的指定枚举类型的枚举常量。

  这里主要说明一下ordinal()方法,该方法获取的是枚举变量在枚举类中声明的顺序,下标从0开始,如日期中的MONDAY在第一个位置,那么MONDAY的ordinal值就是0,如果MONDAY的声明位置发生变化,那么ordinal方法获取到的值也随之变化,注意在大多数情况下我们都不应该首先使用该方法,毕竟它总是变幻莫测的。compareTo(E o)方法则是比较枚举的大小,注意其内部实现是根据每个枚举的ordinal值大小进行比较的。name()方法与toString()几乎是等同的,都是输出变量的字符串形式。至于valueOf(Class<T> enumType, String name)方法则是根据枚举类的Class对象和枚举名称获取枚举常量,注意该方法是静态的,后面在枚举单例时,我们还会详细分析该方法,下面的代码演示了上述方法:

  4.values()方法和valueOf(String name)方法是编译器生成的static方法因此从前面的分析中,在Enum类中并没出现values()方法,但valueOf()方法还是有出现的,只不过编译器生成的valueOf()方法需传递一个name参数,而Enum自带的静态方法valueOf()则需要传递两个方法,从前面反编译后的代码可以看出,编译器生成的valueOf方法最终还是调用了Enum类的valueOf方法。

补充:带抽象方法的枚举类型的应用

  如果我们写一个枚举类型来实现基本的运算,我们可能会写成下面:

public enum Operation {

    PLUS, MINUS, TIMES, DIVIDE;

    public double operate(double num1, double num2) {
switch (this) {
case PLUS:
return num1 + num2;
case MINUS:
return num1 - num2;
case TIMES:
return num1 * num2;
case DIVIDE:
return num1 / num2;
} throw new RuntimeException("err");
} }

  如果我们增加一个新的运算规则需要增加一个新的实例,而且增加一个case分支。

用抽象方法+枚举替代:

public enum Operation {

    PLUS {
@Override
double operate(double num1, double num2) {
return num1 + num2;
}
},
MINUS {
@Override
double operate(double num1, double num2) {
return num1 - num2;
}
},
TIMES {
@Override
double operate(double num1, double num2) {
return num1 * num2;
}
},
DIVIDE {
@Override
double operate(double num1, double num2) {
return num1 / num2;
}
}; abstract double operate(double num1, double num2); }

Java枚举类型的用法的更多相关文章

  1. 深入理解Java枚举类型(enum)

    https://blog.csdn.net/javazejian/article/details/71333103 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(en ...

  2. Java枚举类型的使用,数值的二进制表示

    一.Java枚举类型的使用 首先请看这段代码: package java上课; public class EnumTest { public static void main(String[] arg ...

  3. java 枚举类型分析

    最近做android开发,需要用到枚举值,这样可以连续赋值,我按之前c++那样书写,如下所示: public enum ColorSelect { RED_BAGE = 0, GREEN_BAGE, ...

  4. 【转】java枚举类型enum的使用

    原文网址:http://blog.csdn.net/wgw335363240/article/details/6359614 java 枚举类型enum 的使用 最近跟同事讨论问题的时候,突然同事提到 ...

  5. 【转】掌握java枚举类型(enum type)

    原文网址:http://iaiai.iteye.com/blog/1843553 1   背景 在java语言中还没有引入枚举类型之前,表示枚举类型的常用模式是声明一组具有int常量.之前我们通常利用 ...

  6. 转载 java枚举类型enum的使用 (原文地址:http://blog.csdn.net/wgw335363240/article/details/6359614)

    java枚举类型enum的使用 最近跟同事讨论问题的时候,突然同事提到我们为什么java中定义的常量值不采用enmu枚举类型,而采用public final static 类型来定义呢?以前我们都是采 ...

  7. Java 枚举类型简介

    目录 Java 枚举示例 Java 枚举构造函数 枚举类型是用于定义常量集合的特殊类型,更确切的说,JAVA枚举类型是一种特殊的 java 类.枚举类型可以包含常量.方法等.在 java5 中添加了 ...

  8. 【转载】Java枚举类型的使用

    枚举类型概念 package com.lxq.enumm; public class EnumDemoOne { private enum InnerEnum { RED, GREEN, YELLOW ...

  9. Java枚举类型使用示例

    Java枚举类型使用示例 学习了:https://www.cnblogs.com/zhaoyanjun/p/5659811.html http://blog.csdn.net/qq_27093465/ ...

随机推荐

  1. SGU326_Perspective

    NBA打比赛.所有的比赛被分为多个团队.有的比赛是团内的,有的是与团外的队伍打的. 给出团内每个队伍已得分,以及总共有多少场比赛,还有团内所有队伍之间有多少场比赛? 问1队是否可能是分数最高的一个队伍 ...

  2. python自动化之web抓取

    ''' 从web抓取数据: webbrowser:是python自带的,打开浏览器获取指定页面. requests:从因特网上下载文件和网页. Beautiful Soup:解析HTML,即网页编写的 ...

  3. java中的变量各占得字节数

    boolen,8位1个字节int,32位,4个字节float,32位 4个字节double,64位8个字节char 16位,2个字节byte 8位1个字节short 16位 2个字节long 64位 ...

  4. 初次使用http打不开页面,使用https打开过后使用http协议又能正常访问

    http协议为什么打不开https站点 在访问一个https的站点,比如 https://www.aaa.com,首次访问时,访问的地址是 http://www.aaa.com,(不加S),出现的是网 ...

  5. BZOJ1495 [NOI2006]网络收费 【树形dp + 状压dp】

    题目链接 BZOJ1495 题解 观察表格,实际上就是分\(A\)多和\(B\)两种情况,分别对应每个点选\(A\)权值或者\(B\)权值,所以成对的权值可以分到每个点上 所以每个非叶节点实际对应一个 ...

  6. 用Python实现的数据结构与算法:快速排序

    一.概述 快速排序(quick sort)是一种分治排序算法.该算法首先 选取 一个划分元素(partition element,有时又称为pivot):接着重排列表将其 划分 为三个部分:left( ...

  7. SrervletContext和文件下载

    ServletContext对象 生命周期(从生命周期可以看出这个是个全局对象) 项目启动的时候创建 项目关闭的时候销毁 概念:代表整个web应用,可以和程序的容器(服务器)来通信. 获取 通过req ...

  8. ---web模型 --mvc和模型--struts2 入门

    关于web模型: 早期的web 应用主要是静态页丽的浏览〈如新闻的制监),随着Internet的发展,web应用也变得越来越复杂,不仅要 和数据库进行交互 ,还要和用户进行交互,由此衍生了各种服务器端 ...

  9. tar 命令显示进度条

    实现该功能需要安装 pv,然后把需要处理的数据通过管道传给 pv,最后再进行操作. 传给 pv 的目的是为了知道已经处理的数据量大小,同时需要通过 -s 指定总共需要处理的数据量大小. pv 的安装一 ...

  10. MyEclipse10 Tomcat7关联

    MyEclipse10 Tomcat7配置 配置: 选择Window下的preferences界面 配置jdk,可以选择自己安装的jdk,点击ok就配置好了. 测试: 菜单file>new> ...