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則可以是任意類型。
- 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]
- 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是抽象類),以下是它的常見方法:
這裏主要說明一下ordinal()方法,該方法獲取的是枚舉變量在枚舉類中聲明的順序,下標從0開始,如日期中的MONDAY在第一個位置,那麼MONDAY的ordinal值就是0,如果MONDAY的聲明位置發生變化,那麼ordinal方法獲取到的值也隨之變化,注意在大多數情況下我們都不應該首先使用該方法,畢竟它總是變幻莫測的。compareTo(E o)方法則是比較枚舉的大小,注意其內部實現是根據每個枚舉的ordinal值大小進行比較的。name()方法與toString()幾乎是等同的,都是輸出變量的字符串形式。至於valueOf(Class 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);
}