《Java編程思想》筆記第十九章枚舉類型

阿新 • • 發佈：2018-08-21

void serial final eof coff rabl com 筆記 bstr

1.基本enum特征

所有創建的枚舉類都繼承自抽象類 java.lang.Enum;

一個枚舉類，所有實例都要在第一句寫出以，隔開。如果只有實例最後可以不加；枚舉類因為繼承了Enum,所以再不能繼承別的類，任何類也不能繼承枚舉類（構造器默認為private）。

public enum Color {
    RED,
    BLUE,
    YELLOW,
    PURPLE
}

註意 ：RED,BLUE 這些是由 enum Color類調用默認private構造器創建的實例對象，和普通class相比只不過enum的實例對象只能在內部創建。時刻記著他們是一個實例對象。

枚舉類實例不能在外部 new 出來，因為枚舉類構造器為private 一般也不用聲明private，默認就是private，因為enum實例只能在編譯期間enum類內部被創建，但可以外部得到一個實例的引用。
```
        Color red  = Color.RED;
        Color blue = Color.BLUE;
```
枚舉類的一些方法
1. 　使用枚舉元素 Color.RED 或者 red
2. 　Color.values( ) 返回一個枚舉類數組，數組元素就是枚舉的實例。
3. 　red.ordinal() 方法返回該實例聲明的次序從0開始。
4. 　2個實例可用 == 比較
5. 　Enum 實現了 Comparable<E>和 Serializable 可以使用comparableTo( )方法，可以序列化
6. 　a. getDeclaringClass() 返回 Color.class 對象
7. 　a.name和a.toString( )方法一樣。
8. valuesOf(string ) 返回一個實例對象 Color b = Color.valueOf("BLUE");
9. 　根據class對象返回實例 Color b = Color.valueOf( Color.class, "BLUE" )

通過帶參構造器為枚舉實例添加描述信息。調用 getDes()就可以的到當前對象的描述信息。

public enum Color {
    RED("這是紅色"),
    BLUE("這是藍色"),
    YELLOW( 
"這是黃色"),
    PURPLE("這是紫色");
    String des;
    Color( String s) {
        this.des = s;
    }
    public String getDes(){
        return des;
    }
}

調用 getDes( )方法就可以的到當前對象的描述信息。

重寫toString( )方法來為enum實例添加描述信息。

public enum Color {
    RED,
    BLUE,
    YELLOW,
    PURPLE;

    @Override
    public String toString() {
        String id = name();
        return id + " is " + id.toLowerCase();
    }
}

通過name() 拿到當前對象名字。

2.enum的特殊方法。

除了不能繼承enum類外，enum和其普通類沒區別，可以添加字段，方法，甚至是main 方法

enum 實例也可以用在 switch語句中
values()方法不在Enum中它是由編譯器添加的static方法。
編譯器還添加了一個valuesOf(String s)方法，這個只需要一個參數就可以的得到實例，而Enum的需要2個。
如果將enum向上轉型為Enum那麽values 和 valuesOf 無法再使用。
與values 方法有相同作用的就是Class對象的getEnumConstants()，如果class是枚舉類那麽返回元素數組，不是枚舉類返回null

3. 使用接口組織枚舉

為了實現擴展enum 或者將enum分類，因為無法繼承所以靠擴展子類無法實現，可以利用接口來達到這些功能。

接口內部創建實現該接口的enum 達到分類目的，並且可以向上轉型為接口

public interface Food {
    enum Fruit implements Food{
        APPLE, BANANA, ORANGE;
    }
    enum Vegetables implements Food{
        TOMATO, POTATO, BEANS;
    }
    enum Drink implements Food{
        COFFEE, COCA, REDBULL;
    }
}


   public static void main(String[] args) {
        Food food = Food.Fruit.APPLE;
        food = Food.Drink.REDBULL;
        food = Food.Vegetables.BEANS;
    }

接口基礎上創建一個枚舉的枚舉，通過該enum控制其他enum，而不是不同的類型分別都要向上轉型為Food ，類多時分別向上轉型不如每個用一個enum控制方便。

public enum Course {
    FRUIT(Food.Fruit.class),
    DRINK(Food.Drink.class),
    VEGETABLES(Food.Vegetables.class);
    private Food[] values;
    Course(Class<? extends Food> kind) {
        this.values = kind.getEnumConstants();
    }
    public Food[] getValues() {
        return values;
    }
}

通過實例調用getValues方法就可以的到該實例的所有元素。

enum嵌套在另一個enum 重新組織1 2 代碼合二為一技術分享圖片

public enum Course {
    FRUIT(Food.Fruit.class),
    DRINK(Food.Drink.class),
    VEGETABLES(Food.Vegetables.class);
    private Food[] values;

    Course(Class<? extends Food > kind) {
        this.values = kind.getEnumConstants();
    }

    interface Food {
        enum Fruit implements Food {
            APPLE, BANANA, ORANGE;
        }

        enum Vegetables implements Food {
            TOMATO, POTATO, BEANS;
        }

        enum Drink implements Food {
            COFFEE, COCA, REDBULL;
        }
    }

    public Food[] getValues() {
        return values;
    }
   
}

View Code

4. EnumSet

EnumSet （抽象類）一個用來存放enum 元素的Set,存取enum速度非常快，性能非常高。

EnumSet 只能存放enum元素，不能插入空元素。
放入的元素位置和enum中保持一樣，它處於排序狀態，是一個有序Set.

Enum 是個抽象類且方法除了colon( )克隆一個EnumSet外都是靜態方法返回值都是EnumSet。

  EnumSet<Color> enumSet = EnumSet.noneOf(Color.class); //創建一個空集
        EnumSet<Color> enumSet2 = EnumSet.allOf(Color.class); //把集合中所有元素添加進去
        EnumSet<Color> enumSet3 = EnumSet.of(RED);//添加一個元素

EnumSet不止這幾個方法，對於of() 方法重載了6次，當傳入2-5個參數調用相應方法，傳入1個或者5個以上調用可變參數。

5.EnumMap

特殊Map（類），key必須是enum, 由於enum元素有限所以內部只是由數組實現。

這是一個有序map，保持enum的元素順序。
EnumMap<Color,Object> map = new EnumMap<Color, Object>(Color.class);
方法和其他Map一樣。

6.實例對象添加方法

為每一個enum實例（相當於常量）添加一個方法，讓他們有不同的行為。

為每一個實例添加不同行為的方法
1. 在enum中創建一個或者多個abstract 方法，因為是enum的實例所以就得實現這些方法。
```
   RED{
        @Override
        String getInfo() {
            return null;
        }

        @Override
        String getTime() {
            return null;
        }
    };
    abstract String getInfo();
    abstract String getTime();
```
2. enum也可以有main方法作為enum執行入口
3. 常量添加方法後和有了類的行為，貌似和內部類一樣，但他們有著不同行為，enum的常量不能作為方法參數類型，因為他們不是類，只是enum類型的static final 實例
4. 由於enum的常量是 static final 的所以常量的方法不能訪問外部類的非靜態方法。
覆蓋常量相關的方法
1. enum中所有非抽象方法每個實例都可以調
2. 如果不需要每個實例都實現抽象類，那麽就可以不用定義抽象類，每個實例各自實現方法，實現的方法可以覆蓋enum中的方法。

使用enum職責鏈。

多種不同的方式解決問題，然後把它們連接在一起，但一個請求到達時遍歷整個鏈，直到解決問題。

enum非常適合作為解決某一個問題的職責鏈，請求到達時遍歷整個enum，直到解決問題。技術分享圖片

import java.util.EnumSet;
import java.util.Random;

public enum COR {
    SOLUTION_ONE{
        @Override
        boolean Solve(int i) {
            if (i == 1){
                System.out.println(name()+" 解決問題 " +i);
                return true;
            } return false;
        }
    },
    SOLUTION_TWO{
        @Override
        boolean Solve(int i) {
            if (i == 2){
                System.out.println(name()+" 解決問題 " +i);
                return true;
            }return false;
        }
    },
    SOLUTION_THREE{
        @Override
        boolean Solve(int i) {
            if (i == 3){
                System.out.println(name()+" 解決問題 " +i);
                return true;
            }return false;
        }
    },
    SOLUTION_FOUR{
        @Override
        boolean Solve(int i) {
            if (i == 4){
                System.out.println(name()+" 可以解決問題 " +i);
                return true;
            }return false;
        }
    };

    abstract boolean Solve(int i);

    public static void main(String[] args) {
        Random random = new Random();
        EnumSet<COR> cors = EnumSet.allOf(COR.class);
        for (int i = 0; i < 6; i++) {
            int id = random.nextInt(4)+1;
            for (COR cor :cors) {
                if (cor.Solve(id)){
                    System.out.println(" 解決問題 " +id);
                    break;
                }
            }
        }
    }

}

View Code

enum狀態機
- 狀態機可以具有有限個狀態，通常根據輸入，從一個狀態轉移到下一個狀態，也可以有瞬時狀態，一但任務結束就立刻離開瞬時狀態。

7.多路分發

多種類型交互時有時並不能確定所有類型，如： NUM.complete(NUM) , NUM 是所有數字類型的超類，a.complete(b) ,a b可能是同種類型也可能不是同一種類型。
Java 動態綁定只能處理一種類型，屬於單路分發（分派），動態綁定能將complete綁定到分路a。只有方法調用才會執行動態綁定。

可以為每一個分發實現自己的動態綁定技術分享圖片

public enum Outcome { WIN, LOSE, DRAW } ///:~  
  
  
interface Item {  
    Outcome compete(Item it);  
  
    Outcome eval(Paper p);  
  
    Outcome eval(Scissors s);  
  
    Outcome eval(Rock r);  
}  
  
class Paper implements Item {  
    public Outcome compete(Item it) {  
        return it.eval(this);  
    }  
  
    public Outcome eval(Paper p) {  
        return DRAW;  
    }  
  
    public Outcome eval(Scissors s) {  
        return WIN;  
    }  
  
    public Outcome eval(Rock r) {  
        return LOSE;  
    }  
  
    public String toString() {  
        return "Paper";  
    }  
}  
  
class Scissors implements Item {  
    public Outcome compete(Item it) {  
        return it.eval(this);  
    }  
  
    public Outcome eval(Paper p) {  
        return LOSE;  
    }  
  
    public Outcome eval(Scissors s) {  
        return DRAW;  
    }  
  
    public Outcome eval(Rock r) {  
        return WIN;  
    }  
  
    public String toString() {  
        return "Scissors";  
    }  
}  
  
class Rock implements Item {  
    public Outcome compete(Item it) {  
        return it.eval(this);  
    }  
      
    public Outcome eval(Paper p) {  
        return WIN;  
    }  
  
    public Outcome eval(Scissors s) {  
        return LOSE;  
    }  
  
    public Outcome eval(Rock r) {  
        return DRAW;  
    }  
  
    public String toString() {  
        return "Rock";  
    }  
}  
  
public class RoShamBo1 {  
    static final int SIZE = 20;  
    private static Random rand = new Random(47);  
  
    public static Item newItem() {  
        switch (rand.nextInt(3)) {  
        default:  
        case 0:  
            return new Scissors();  
        case 1:  
            return new Paper();  
        case 2:  
            return new Rock();  
        }  
    }  
  
    public static void match(Item a, Item b) {  
        System.out.println(a + " vs. " + b + ": " + a.compete(b));  
    }  
  
    public static void main(String[] args) {  
        for (int i = 0; i < SIZE; i++)  
            match(newItem(), newItem());  
    }  
}

View Code

使用enum實現多路分發

enum的實例不能作為類型參數，不可以重載方法。

可以使用enum構造器初始化每個enum實例，並以一組結果作為參數如 ENUM_A( vsA_DRAW, vsB_LOSE, vsC_WIN ) 在比較方法中使用switch 判斷返回結果技術分享圖片

package enums;

import static enums.OutCome.*;

public enum RoSham {
    PAPER(DRAW, LOSE, WIN),
    SCISSORS(WIN, DRAW, LOSE),
    ROCK(LOSE, WIN, DRAW);

    private OutCome vPAPER, vSCISSORS, vROCK;

    RoSham(OutCome paper, OutCome scissors, OutCome rock) {
        this.vPAPER = paper;
        this.vSCISSORS = scissors;
        this.vROCK = rock;
    }

    public OutCome complete(RoSham it) {
        switch (it) {
            default:
            case PAPER:
                return vPAPER;
            case SCISSORS:
                return vSCISSORS;
            case ROCK:
                return vROCK;
        }
    }

    public static void main(String[] args) {
        System.out.println(PAPER.complete(ROCK));
    }
}

View Code

PAPER.complete（）時把PAPER構造器中的結果與 OutCome 變量綁定，根據對比的參數返回對比結果，因此實例構造器中的參數位置非常重要、

使用EnumMap

EnumMap實現真正的多路分發技術分享圖片

package enums;

import java.util.EnumMap;

import static enums.OutCome.*;

public enum RoShamBo {
    PAPER, SCISSORS, ROCK;
    static EnumMap<RoShamBo, EnumMap<RoShamBo, OutCome>>
            table = new EnumMap<RoShamBo, EnumMap<RoShamBo, OutCome>>(RoShamBo.class);

    static {
        for (RoShamBo it : RoShamBo.values()) {

            table.put(it, new EnumMap<RoShamBo, OutCome>(RoShamBo.class));
        }

        initRow(PAPER, DRAW, LOSE, WIN);
        initRow(SCISSORS, WIN, DRAW, LOSE);
        initRow(ROCK, LOSE, WIN, DRAW);

    }

    static void initRow(RoShamBo it, OutCome vPAPER, OutCome vSCISSORS, OutCome vROCK) {
        EnumMap<RoShamBo, OutCome> row = RoShamBo.table.get(it);
        row.put(RoShamBo.PAPER, vPAPER);
        row.put(RoShamBo.SCISSORS, vSCISSORS);
        row.put(RoShamBo.ROCK, vROCK);
    }

    public OutCome complete(RoShamBo it) {
        return table.get(this).get(it);
    }

    public static void main(String[] args) {
        System.out.println(ROCK.complete(SCISSORS));
    }

}

View Code

complete方法實現了2次分發

使用二維數組

簡單，速度快，代碼易懂，但是組數比較大時尺寸容易錯

  private static OutCome[][] tables = {
        {DRAW, LOSE, WIN},
        {WIN, DRAW, LOSE},
        {LOSE, WIN, DRAW},
    };

    public OutCome completes (RoShamBo other) {
        return tables[this.ordinal()][other.ordinal()];
    }

知識點

可以靜態導入枚舉類直接使用枚舉實例 import static ......Color.* 最好使用靜態導入省去寫enum類。

《Java編程思想》筆記第十九章枚舉類型

void serial final eof coff rabl com 筆記 bstr 1.基本enum特征所有創建的枚舉類都繼承自抽象類 java.lang.Enum; 一個枚舉類，所有實例都要在第一句寫出以，隔開。如果只有實例最後可以不加；枚舉類因為

第十五章枚舉類型和位標誌

數據第十五章數值符號方法強類型模擬枚舉類類型目錄： 15.1 枚舉類型和位標誌 15.2 位標誌 15.3 向枚舉類型添加方法 15.1 枚舉類型和位標誌枚舉類型定義了一組“符號名稱/值”配對。枚舉類型使程序更容易編寫，閱讀和維護。枚舉類型時強類型的

java編程思想筆記--第一個java程序

有趣要花 run 作用 arc 屬性環境 pro 做的 // Property.java import java.util.*; public class Property { public static void main(String[]

Java編程思想筆記-對象比較

urn bool equals print 方法編程對象 stat == public class EqualsTest { 　　public int i； } public class Test { 　　public static void main(String

Java編程思想筆記-類的初始化順序

rup cep main mark java boa marker 內存類的初始化 1、如果有父類，先初始化父類，然後初始化子類 2、先初始化靜態成員變量、靜態代碼塊（static { }包圍的代碼），然後初始化非靜態成員變量、非靜態代碼塊（大括號包圍的代碼）。靜態成員變

Java編程思想 4th 第2章一切都是對象

reference 報錯編程必須返回 -1 color 處理是什麽 Java是基於C++的，但Java是一種更純粹的面向對象程序設計語言，和C++不同的是，Java只支持面向對象編程，因此Java的編程風格也是純OOP風格的，即一切都是類，所有事情在類對象中完成。

《java程式設計思想》第十九章列舉

enum的values()方法返回enum例項的陣列，而且該陣列中的元素嚴格保持其在enum中聲宣告時的順序。建立enum時，編譯器會為你生成一個相關的類，這個類繼承自java.lang.Enum。 Enum類例項的ordinal()方法返回一個int值

《JAVA編程思想》第四版 PDF 下載中文版和英文版高清PDF掃描帶書簽

level java pic blog mirror 參考 aid app 整體一、鏈接：中文版： https://pan.baidu.com/s/1d07Kp4 密碼:x2cd 英文版： https://pan.baidu.com/s/1boOSdAZ 密碼: rwg

【Java編程思想筆記】註解--自定義註解

password admin lamp sta 如果 amp 部分 oot nbsp 文章參考自：https://www.cnblogs.com/xdp-gacl/p/3622275.html 學習網站：how2java.cn

《Linux命令行與shell腳本編程大全》第十五章呈現數據

orm while 永久 date txt 沒有電子必須 document 15.1 理解輸入和輸出現在知道兩種顯示腳本輸出的方法 1）在顯示器屏幕上顯示 2）將輸出文件重定向到文件中 15.1.1 標準文件描述符 Linux系統將每個對象當做文件處理。這包括輸入和數

機器學習學習筆記第十九章聚類演算法-K-MEANS

聚類演算法聚類的概念：主要用來處理無監督問題，因為我們手上沒有標籤了，靠電腦自己進行分類聚類是指把相似的東西分到一組難點如何評估呢（因為沒有了標籤，難以對比正確與否，很多評估方法失效了）

Python 編程快速上手第十一章 Web scrapping

soup href 列表前言 n) 自動模擬鼠標相關 lec 前言這一章講了如何在 Web 上抓取相關的信息，工具是三個模塊： webbrowser 模塊：用於打開瀏覽器指定頁面 requests 模塊：用於下載文件 Beautiful Soup 模塊：用於解析

Python 編程快速上手第十八章用 GUI 自動化控制鍵盤和鼠標

mouse tab 坐標鼠標右鍵以及移動前言狀態 elm 前言這一章節講述了如何實現 GUI 自動化，首先講了一些處理異常狀況的方法，然後是關於 GUI 自動化的內容，主要有三個部分：控制鼠標圖像識別控制鍵盤下面引用一段話：請將 GUI 自動化看

【WPF學習】第十九章控制元件類

　　WPF視窗充滿了各種元素，但這些元素中只有一部分是控制元件。在WPF領域，控制元件通常被描述為與使用者互動的元素——能接收焦點並接受鍵盤或滑鼠輸入的元素。明顯的例子包括文字框和按鈕。然而，這個區別有時有些模糊。將工具提示視為控制元件，因為它根據使用者滑鼠的移動顯示或消失。將標籤視為

《Java編程思想》筆記第十二章通過異常處理錯誤

nts 無法 ble 多個打印 while循環 sage 返回機制 1.異常也是對象標準異常類都有兩個構造器，一個默認，一個接受字符串。 1.1 拋異常與方法返回類型不同，但有相似效果使當前方法退出並返回，拋異常可以看作是一種不同的返回機制。（異同點不必深究）

《Java編程思想》筆記第九章接口

上轉型有一個 abstract 5.1 pan ace 避免 AC 內部 1.抽象類和抽象方法 1.1 抽象方法，僅有方法聲明沒有方法體 abstract class AbstractClass{ abstract void f(); //沒有 {}

《Java編程思想》筆記第十章內部類

處理 this 都是多層不能 RM 互訪 4.2 引用調用 1.創建內部類對象 1.1 創建內部類對象（相當於new內部類對象）外圍類對象.new 內部類( )。 1.2 創建內部類對象一種方法是外圍類有一個方法返回內部類對象。 1.3 沒有外圍類對象就不能創建內部

《Java編程思想》筆記第十一章持有對象

而且位置 pty dex 優先級 poll IT ise 註意 1.保存對象引用 1.數組，數組具有固定大小 2.容器類，可自動調節大小 2.容器類 List Set Queue Map 及常用的實現類 2.1 Collectioon （接口）保存獨立

《Java編程思想》筆記第十七章容器深入研究

let 類庫 font 有關有一個 www. 強引用容器類刪除 1 容器分類容器分為Collection集合類，和Map鍵值對類2種使用最多的就是第三層的容器類，其實在第三層之上還有一層Abstract 抽象類，如果要實現自己的集合類，可以繼承Abstract類

《Java並發編程實戰》第十章避免活躍性危急讀書筆記

for 分析 tac mage cas 系統 ron htm 發生一、死鎖所謂死鎖：是指兩個或兩個以上的進程在運行過程中。因爭奪資源而造成的一種互相等待的現象。若無外力作用。它們都將無法推進下去。百科百科當兩個以上的運算單元，兩方都在等待對方停止執

《Java編程思想》筆記 第十九章 枚舉類型

1.基本enum特征

2.enum的特殊方法。

3. 使用接口組織枚舉

4. EnumSet

5.EnumMap

6.實例對象添加方法

7.多路分發

知識點

相關推薦

《Java編程思想》筆記第十九章枚舉類型