傳送門:http://blog.csdn.net/qq_27093465/article/details/52181860
JDK1.5引入了新的類型——枚舉。在 Java 中它雖然算個“小”功能,卻給我的開發帶來了“大”方便。
大師兄我又加上自己的理解,來幫助各位理解一下。
用法一:常量
在JDK1.5 之前,我們定義常量都是: public static fianl.... 。現在好了,有了枚舉,可以把相關的常量分組到一個枚舉類型裏,而且枚舉提供了比常量更多的方法。
- public enum Color {
- RED, GREEN, BLANK, YELLOW
- }
用法二:switch
JDK1.6之前的switch語句只支持int,char,enum類型,使用枚舉,能讓我們的代碼可讀性更強。
- 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 實例。
- 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()方法覆蓋的例子。
- 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;
- }
- }
用法五:實現接口
所有的枚舉都繼承自java.lang.Enum類。由於Java 不支持多繼承,所以枚舉對象不能再繼承其他類。
- 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);
- }
- }
用法六:使用接口組織枚舉
Java代碼
- 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文檔。
關於枚舉的實現細節和原理請參考:
參考資料:《ThinkingInJava》第四版
http://softbeta.iteye.com/blog/1185573
我的這篇文章,因爲是轉載的,可能基本就沒有變動,導致被某人踩了一腳。覺得不符合我大師兄的性格。下面我把自己的使用理解給整理一下。
也是因爲因爲當時剛剛開始學習吧。把平時自以爲了解的東西都只是大概瞭解了一下,說到底,還是自以爲了解了,其實轉眼就不知道什麼是什麼了。
出來學習,不習慣看代碼怎麼能行呢?
下面是我自己的測試代碼。
然後是測試的結果圖:
簡單的例子,大家基本都用過,看不懂的基本都是第二個例子。可以看到,在第二個例子裏面,後面帶有參數,其實可以這麼理解。
enum這個關鍵字,可以理解爲跟class差不多,這也個單獨的類。可以看到,上面的例子裏面有屬性,有構造方法,有getter,也可以有setter,但是一般都是構造傳參數。還有其他自定義方法。那麼在這些東西前面的,以逗號隔開的,最後以分號結尾的,這部分叫做,這個枚舉的實例。也可以理解爲,class new 出來的實例對象。這下就好理解了。只是,class,new對象,可以自己隨便new,想幾個就幾個,而這個enum關鍵字,他就不行,他的實例對象,只能在這個enum裏面體現。也就是說,他對應的實例是有限的。這也就是枚舉的好處了,限制了某些東西的範圍,舉個栗子:一年四季,只能有春夏秋冬,你要是字符串表示的話,那就海了去了,但是,要用枚舉類型的話,你在enum的大括號裏面把所有的選項,全列出來,那麼這個季節的屬性,對應的值,只能在裏面挑。不能有其他的。
我上面的例子,就是根據typeName,你可以從那些例子裏面挑選到唯一的一個TYPE類型的枚舉實例--TYPE.BALANCE。注意方法
TYPE type = TYPE.fromTypeName(typeName);
這個方法的返回類型就是這個TYPE枚舉類型的。
這下就好理解,這個枚舉是怎麼在工作了吧
再補充一下:
上面那個帶參數的枚舉類型的實例裏面實際上是三個屬性,除了我自定義的typeName以外,還有2個是系統自帶的。看下面源碼的圖:
看到這裏之後,不知道你能不能理解下面圖片內說明的話:下面圖片主要說明在使用枚舉時,的規範和標準。希望可以在實際開發時候用到
最後補充一點:
也許你知道呢,但是也許你不知道呢?我是真的不知道,測了之後才知道!!!
枚舉類型對象之間的值比較,是可以使用==,直接來比較值,是否相等的,不是必須使用equals方法的喲。
具體,請參考下面的鏈接:
轉自:http://blog.csdn.net/yehui928186846/article/details/51426415
基本特性:
1,enum關鍵字
枚舉enum是同class,interface同一級別的特性。
我們可以把enum看作一個抽象類,但是它又有它的不同之處,enum不能被繼承。
這一點其實在Android源碼中就得到了證實:
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
從源碼中可以看出Enum相當於一個抽象類。所以,enum可以看成一個抽象類並且和class、interface同級。
2,枚舉的定義
如何在Enum中定義枚舉常量呢?
1,枚舉常量沒有任何修飾符
2,每個常量以“,”分隔,以“;”結束枚舉常量的描述。
3,枚舉常量必須定義在所有方法或者構造器之前。
規矩我們已經知道了,接下來就看看如何在代碼裏定義枚舉常量了:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
3,使用枚舉的目的
當我們需要限制一系列變量的時候,通常想到數組或者集合;其實很多時候我們需要限定變量需要做的事情很多,或者說如果被限制的變量可以做其他事情的話就更好了,而不是單純的一個變量(String,int,double)。
那麼,枚舉的作用不僅僅可以讓你使用限制在一個enum中的變量,並且這些變量的靈活性和拓展性很好。
舉例說明:
如果我們需要使用一些狀態,比如一個星期的狀態。
我們可以用數組:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
或者集合,這些表示大家都很熟悉。
那麼看看用枚舉如何來寫:
- 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
- 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
可能,有人會說,這樣寫可是很麻煩。的確比數組或者集合麻煩了,但是它的拓展性是非常好的,因爲往往我們需要的不僅僅是一個字符串,不僅僅是調用數字得到一個以供顯示的星期,而是更多的邏輯處理。
我們來重寫一下枚舉中getWeek方法:
- 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
- 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
這時候,枚舉的有點久體現出來了,不僅僅可以獲得狀態,還可以在枚舉中處理邏輯。
這是數組或者集合無法做到了,而且枚舉完成的邏輯不僅僅這些,還能完成更多更復雜的邏輯處理。
4,使用枚舉
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
我們可以通過這四種方式根據不同的情景來使用相應的枚舉處理一些複雜的邏輯。
總結:
當我們在需要控制一個方法傳入的參數的時候,並且這些參數可以自己處理一些事情的時候我們就可以選擇枚舉來實現。
例如:時間選擇格式,我們可以用枚舉來規定格式,然後外界只能調用枚舉中的格式,然後枚舉再去將規定的格式傳給時間用於格式化。
所有的邏輯處理交給枚舉來完成,我們只需要調用相應的枚舉類型就能得到想要的時間格式的時間。
還有很多地方都體現出枚舉的好處,例如:網絡請求的接口定義;一些輯返回參數的定義;
只要是需要控制變量的數量或者範圍,並且拿到變量後還需要處理一些邏輯的場景都可以用枚舉來完成