Java枚舉用法詳解

用法一：常量

在JDK1.5 之前，我們定義常量都是： public static fianl.... 。現在好了，有了枚舉，可以把相關的常量分組到一個枚舉類型裏，而且枚舉提供了比常量更多的方法。

1
2
3
public enum Color {
RED, GREEN, BLANK, YELLOW
}
用法二：switch

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
enum Signal {
GREEN, YELLOW, RED
}

public class TrafficLight {
    Signal color = Signal.RED;

    public void change() {
        switch (color) {
        case RED:
            color = Signal.GREEN;
            break;
        case YELLOW:
            color = Signal.RED;
            break;
        case GREEN:
            color = Signal.YELLOW;
            break;
        }
    }
}

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

如果打算自定義自己的方法，那麼必須在enum實例序列的最後添加一個分號。而且 Java 要求必須先定義 enum 實例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public enum Color {
RED("紅色", 1), GREEN("綠色", 2), BLANK("白色", 3), YELLO("×××", 4);
// 成員變量
private String name;
private int index;

    // 構造方法
    private Color(String name, int index) {
        this.name = name;
        this.index = index;
    }

    // 普通方法
    public static String getName(int index) {
        for (Color c : Color.values()) {
            if (c.getIndex() == index) {
                return c.name;
            }
        }
        return null;
    }

    // get set 方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }
}

用法四：覆蓋枚舉的方法

下面給出一個toString()方法覆蓋的例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Test {
public enum Color {
RED("紅色", 1), GREEN("綠色", 2), BLANK("白色", 3), YELLO("×××", 4);
// 成員變量
private String name;
private int index;

    // 構造方法
    private Color(String name, int index) {
        this.name = name;
        this.index = index;
    }

    // 覆蓋方法
    @Override
    public String toString() {
        return this.index + "_" + this.name;
    }
}

public static void main(String[] args) {
    System.out.println(Color.RED.toString());
}

}
用法五：實現接口

所有的枚舉都繼承自java.lang.Enum類。由於Java 不支持多繼承，所以枚舉對象不能再繼承其他類。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public interface Behaviour {
void print();

    String getInfo();
}

public enum Color implements Behaviour {
    RED("紅色", 1), GREEN("綠色", 2), BLANK("白色", 3), YELLO("×××", 4);
    // 成員變量
    private String name;
    private int index;

    // 構造方法
    private Color(String name, int index) {
        this.name = name;
        this.index = index;
    }

    // 接口方法

    @Override
    public String getInfo() {
        return this.name;
    }

    // 接口方法
    @Override
    public void print() {
        System.out.println(this.index + ":" + this.name);
    }
}

用法六：使用接口組織枚舉

1
2
3
4
5
6
7
8
9
public interface Food {
enum Coffee implements Food {
BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO
}

    enum Dessert implements Food {
        FRUIT, CAKE, GELATO
    }
}

用法七：關於枚舉集合的使用

java.util.EnumSet和java.util.EnumMap是兩個枚舉集合。EnumSet保證集合中的元素不重複;EnumMap中的 key是enum類型，而value則可以是任意類型。關於這個兩個集合的使用就不在這裏贅述，可以參考JDK文檔

枚舉和常量定義的區別

一、通常定義常量方法

我們通常利用public final static方法定義的代碼如下，分別用1表示紅燈，3表示綠燈，2表示黃燈。

1
2
3
4
5
6
7
8
9
10
public class Light {
/ 紅燈 /
public final static int RED = 1;

    /* 綠燈 */
    public final static int GREEN = 3;

    /* 黃燈 */
    public final static int YELLOW = 2;
}

二、枚舉類型定義常量方法

枚舉類型的簡單定義方法如下，我們似乎沒辦法定義每個枚舉類型的值。比如我們定義紅燈、綠燈和黃燈的代碼可能如下：

1
2
3
public enum Light {
RED, GREEN, YELLOW;
}
我們只能夠表示出紅燈、綠燈和黃燈，但是具體的值我們沒辦法表示出來。別急，既然枚舉類型提供了構造函數，我們可以通過構造函數和覆寫toString方法來實現。首先給Light枚舉類型增加構造方法，然後每個枚舉類型的值通過構造函數傳入對應的參數，同時覆寫toString方法，在該方法中返回從構造函數中傳入的參數，改造後的代碼如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public enum Light {

// 利用構造函數傳參
RED(1), GREEN(3), YELLOW(2);

// 定義私有變量
private int nCode;

// 構造函數，枚舉類型只能爲私有
private Light(int _nCode) {

    this.nCode = _nCode;

}

@Override
public String toString() {

    return String.valueOf(this.nCode);

}

}
三、完整示例代碼

枚舉類型的完整演示代碼如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
public class LightTest {

// 1.定義枚舉類型

public enum Light {

    // 利用構造函數傳參

    RED(1), GREEN(3), YELLOW(2);

    // 定義私有變量

    private int nCode;

    // 構造函數，枚舉類型只能爲私有

    private Light(int _nCode) {

        this.nCode = _nCode;

    }

    @Override
    public String toString() {

        return String.valueOf(this.nCode);

    }

}

/**
 * 
 * @param args
 */

public static void main(String[] args) {

    // 1.遍歷枚舉類型

    System.out.println("演示枚舉類型的遍歷 ......");

    testTraversalEnum();

    // 2.演示EnumMap對象的使用

    System.out.println("演示EnmuMap對象的使用和遍歷.....");

    testEnumMap();

    // 3.演示EnmuSet的使用

    System.out.println("演示EnmuSet對象的使用和遍歷.....");

    testEnumSet();

}

/**
 * 
 * 演示枚舉類型的遍歷
 */

private static void testTraversalEnum() {

    Light[] allLight = Light.values();

    for (Light aLight : allLight) {

        System.out.println("當前燈name：" + aLight.name());

        System.out.println("當前燈ordinal：" + aLight.ordinal());

        System.out.println("當前燈：" + aLight);

    }

}

/**
 * 
 * 演示EnumMap的使用，EnumMap跟HashMap的使用差不多，只不過key要是枚舉類型
 */

private static void testEnumMap() {

    // 1.演示定義EnumMap對象，EnumMap對象的構造函數需要參數傳入,默認是key的類的類型

    EnumMap<Light, String> currEnumMap = new EnumMap<Light, String>(

    Light.class);

    currEnumMap.put(Light.RED, "紅燈");

    currEnumMap.put(Light.GREEN, "綠燈");

    currEnumMap.put(Light.YELLOW, "黃燈");

    // 2.遍歷對象

    for (Light aLight : Light.values()) {

        System.out.println("[key=" + aLight.name() + ",value="

        + currEnumMap.get(aLight) + "]");

    }

}

/**
 * 
 * 演示EnumSet如何使用，EnumSet是一個抽象類，獲取一個類型的枚舉類型內容<BR/>
 * 
 * 可以使用allOf方法
 */

private static void testEnumSet() {

    EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);

    for (Light aLightSetElement : currEnumSet) {

        System.out.println("當前EnumSet中數據爲：" + aLightSetElement);

    }

}

}
執行結果如下：

演示枚舉類型的遍歷 ......

當前燈name：RED

當前燈ordinal：0

當前燈：1

當前燈name：GREEN

當前燈ordinal：1

當前燈：3

當前燈name：YELLOW

當前燈ordinal：2

當前燈：2

演示EnmuMap對象的使用和遍歷.....

[key=RED,value=紅燈]

[key=GREEN,value=綠燈]

[key=YELLOW,value=黃燈]

演示EnmuSet對象的使用和遍歷.....

當前EnumSet中數據爲：1

當前EnumSet中數據爲：3

當前EnumSet中數據爲：2

四、通常定義常量方法和枚舉定義常量方法區別

以下內容可能有些無聊，但絕對值得一窺

代碼：

1
2
3
4
5
6
7
public class State {

public static final int ON = 1;

public static final Int OFF= 0;

}
有什麼不好了，大家都這樣用了很長時間了，沒什麼問題啊。

首先，它不是類型安全的。你必須確保是int

其次，你還要確保它的範圍是0和1

最後，很多時候你打印出來的時候，你只看到 1 和0 ，

但其沒有看到代碼的人並不知道你的企圖，拋棄你所有舊的public static final常量

可以創建一個enum類，把它看做一個普通的類。除了它不能繼承其他類了。(java是單繼承，它已經繼承了Enum),

可以添加其他方法，覆蓋它本身的方法

switch()參數可以使用enum了
values()方法是編譯器插入到enum定義中的static方法，所以，當你將enum實例向上轉型爲父類Enum是，values()就不可訪問了。解決辦法：在Class中有一個getEnumConstants()方法，所以即便Enum接口中沒有values()方法，我們仍然可以通過Class對象取得所有的enum實例
無法從enum繼承子類，如果需要擴展enum中的元素，在一個接口的內部，創建實現該接口的枚舉，以此將元素進行分組。達到將枚舉元素進行分組。
使用EnumSet代替標誌。enum要求其成員都是唯一的，但是enum中不能刪除添加元素。
EnumMap的key是enum，value是任何其他Object對象。
enum允許程序員爲eunm實例編寫方法。所以可以爲每個enum實例賦予各自不同的行爲。
使用enum的職責鏈(Chain of Responsibility) .這個關係到設計模式的職責鏈模式。以多種不同的方法來解決一個問題。然後將他們鏈接在一起。當一個請求到來時，遍歷這個鏈，直到鏈中的某個解決方案能夠處理該請求。
使用enum的狀態機
使用enum多路分發

作者：rhino

鏈接：www.cnblogs.com/happyPawpaw/archive/2013/04/09/3009553.html

Java枚舉用法詳解

有什麼可以快速剪切音樂的工具

電腦錄製的音頻文件如何轉換爲MP3格式

怎麼把歌曲剪切合併在一起？

視頻中提取音頻的方法如何操作

Java中使用redisTemplate操作緩存示例

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結