Java枚舉類型的用法

時間  2019-11-21
標籤 java 枚舉 類型 用法 欄目 Java 简体版
原文   原文鏈接

　　JDK1.5引入了新的類型——枚舉。在 Java 中它雖然算個「小」功能，卻給個人開發帶來了「大」方便。java

1.用法一:常量

　　在JDK1.5 以前，咱們定義常量都是： public static fianl....(這種方式在如今項目中也很常見) 。如今好了，有了枚舉，能夠把相關的常量分組到一個枚舉類型裏，並且枚舉提供了比常量更多的方法。並且枚舉類型能夠幫助咱們檢測許多的編譯失誤。ide

例如:測試

package enumTest;

public enum Color {
    RED,BLANK,YELLOW
}

 

測試代碼:ui

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
BLANKthis

 

2.用法二：switch

　　JDK1.6以前的switch語句只支持int,char,enum類型，使用枚舉，能讓咱們的代碼可讀性更強。 spa

    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;
        }
    }

結果:code

　　紅色對象

 

3.用法三：向枚舉中添加新方法

　　若是打算自定義本身的方法，那麼必須在enum實例序列的最後添加一個分號。並且 Java 要求必須先定義 enum 實例。 且枚舉類型的構造方法必須爲私有方法。blog

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);

}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程