1 列舉引入

Java是一門面向物件的語言，當我們創建好一個類以后，可以創建這個類的多個物件
但是一個類究竟創建多少個物件，并且物件代表的值我們是無法限制的
所以，如果開發中需要一組值，需要的資料是明確的，就可以使用列舉

2 列舉概念

列舉類是一種特殊形式的Java類，列舉類的物件個數是有限且明確的，比如：

星期：Monday(星期一)…Sunday(星期天)
性別：Man(男)、Woman(女)
季節：Spring(春天)…Winter(冬天)
支付方式：Cash(現金)、WeChatpay(微信支付)、AliPay(支付寶支付)、BankCard(銀行卡支付)、CreditCard(信用卡支付)
訂單狀態：Nonpayment(未付款)、Paid(已付款)、Fulfilled(已配貨)、Delivered(已發貨)、Return(退貨)、Checked(已識訓)

所以，如果當我們需要定義一組常量表示不同的狀態時，就建議使用列舉類
JDK5以前是需要自定義列舉類的，JDK5以后可以使用關鍵字enum來定義列舉類
我們先來用傳統class的方式來實作自定義列舉類：

3 自定義列舉類

列舉類中宣告的每一個列舉值代表列舉類的一個實體物件
與Java中的普通類一樣，在宣告列舉類時，也可以宣告屬性、方法和建構式
但是列舉類的建構式必須為私有的，我們一起來練習一下：

package cn.cxy.exec;
/*本類用于自定義列舉類*/
public class SeasonTest {
    public static void main(String[] args) {
        System.out.println(Season.SPRING.getSEASON_NAME());//春季
        System.out.println(Season.SUMMER.getSEASON_DESC());//夏日炎炎
        System.out.println(Season.AUTUMN);
        //Season{SEASON_NAME='秋季', SEASON_DESC='秋高氣爽'}
    }
}
//1.自定義列舉類
class Season{
    //2.定義本類的私有屬性,為了防止值被修改，需要設定為final
    private final String SEASON_NAME;//季節名
    private final String SEASON_DESC;//季節描述

    //3.私有化本類的構造方法--防止外界隨意創建本類物件
    private Season(String seasonName,String seasonDesc){
        this.SEASON_NAME = seasonName;//在構造中給本類的屬性賦值
        this.SEASON_DESC = seasonDesc;
    }

    //4.提供當前列舉類的多個物件
    public final static Season SPRING = new Season("春季","春暖花開");
    public final static Season SUMMER = new Season("夏季","夏日炎炎");
    public final static Season AUTUMN = new Season("秋季","秋高氣爽");
    public final static Season WINTER = new Season("冬季","冬雪凜凜");

    //5.生成對應的get的方法，獲取本類的兩個屬性值
    public String getSEASON_NAME() {
        return SEASON_NAME;
    }
    public String getSEASON_DESC() {
        return SEASON_DESC;
    }
    //6.生成toString方法方便查看

    @Override
    public String toString() {
        return "Season{" +
                "SEASON_NAME='" + SEASON_NAME + '\'' +
                ", SEASON_DESC='" + SEASON_DESC + '\'' + '}';
    }
}

4 使用關鍵字enum定義列舉類

package cn.cxy.exec;

/*本類用于使用enum關鍵字定義列舉類*/
public class ColorTest {
    public static void main(String[] args) {
        //6.進行測驗
        System.out.println(Color.RED);//RED
        System.out.println(Color.ORANGE.getCOLOR_NAME());//橙色
        System.out.println(Color.ORANGE.getCOLOR_NUMBER());//2
    }
}

//1.使用enum關鍵字定義列舉類
enum Color {
    //2.寫出本類對應的多個列舉物件
    /*1.public static final可以省略不寫
    * 2.列舉物件不能像自定義列舉類物件時new,要按照下面的語法：
    * 列舉名1(值1，值2)，列舉名2(值1，值2)，列舉名3(值1，值2);
    * 3.不需要生成toString,因為使用enum關鍵字定義的列舉類繼承了java.lang.Enum
    * 在Enum中重寫了繼承自Object的toString(),直接列印的就是列舉名*/
    RED("紅色",1),
    ORANGE("橙色",2),
    YELLOW("黃色",3),
    GREEN("綠色",4),
    CYAN("青色",5),
    BLUE("藍色",6),
    PURPLE("紫色",7);

    //3.定義列舉類的多個私有屬性
    private final String COLOR_NAME;
    private final int COLOR_NUMBER;

    //4.定義本類的構造方法
    private Color(String colorName, int colorNumber) {
        this.COLOR_NAME = colorName;
        this.COLOR_NUMBER = colorNumber;
    }

    //5.生成屬性對應的兩個get()
    public String getCOLOR_NAME() {
        return COLOR_NAME;
    }
    public int getCOLOR_NUMBER() {
        return COLOR_NUMBER;
    }
}

總結：

1. public static final可以省略不寫
2. 列舉物件不能像自定義列舉類物件時new,要按照下面的語法：
   列舉名1(值1，值2)，列舉名2(值1，值2)，列舉名3(值1，值2);
3. 不需要生成toString,因為使用enum關鍵字定義的列舉類繼承了java.lang.Enum
   在Enum中重寫了繼承自Object的toString(),直接列印的就是列舉名

5 實作介面的列舉類

列舉類也可以實作介面、或繼承抽象類,有兩種實作方案：
方案一：列舉類與介面建立實作關系，在列舉類中實作介面中定義的抽象方法
效果：每個列舉物件呼叫實作后的方法都是同一個效果
方案二：列舉類與介面建立實作關系，在列舉類每個列舉物件后分別實作抽象方法
效果：不同的列舉物件呼叫實作后的方法就是不同的效果

package cn.cxy.exec;
/*本類用于實作列舉實作介面*/
public class TestGame {
    public static void main(String[] args) {
        //8.進行測驗
        Game.ROCK.show();//猜丁殼出的是石頭
        Game.SCISSORS.show();//猜丁殼出的是剪刀
        Game.PAPER.show();//猜丁殼出的是布

        System.out.println(Game.ROCK.getName());//石頭
        System.out.println(Game.ROCK.getNum());//0
    }
}
//6.定義介面與介面中的抽象方法
interface Info{
    void show();
}
//1.通過enum關鍵字定義列舉類
enum Game implements Info{
    //2.列出本類的列舉物件
    ROCK("石頭",0){
        //7.2在每個列舉物件后實作介面的抽象方法
        public void show() {
            System.out.println("猜丁殼出的是石頭");
        }
    },
    SCISSORS("剪刀",2){
        public void show() {
            System.out.println("猜丁殼出的是剪刀");
        }
    },
    PAPER("布",5){
        public void show() {
            System.out.println("猜丁殼出的是布");
        }
    };
    //3.定義本類的屬性
    private final String name;
    private final int num;
    //4.創建本類的建構式
    private Game(String name,int num){
        this.name = name;
        this.num = num;
    }
    //5.生成屬性對應的get()
    public String getName() {
        return name;
    }
    public int getNum() {
        return num;
    }

    //7.1列舉實作介面抽象方法，方案一
//    @Override
//    public void show() {
//        System.out.println("猜丁殼游戲~");
//    }
}

6 Enum類的主要方法

String name() 回傳此列舉常量的名稱，在其列舉宣告中對其進行宣告
int ordinal() 回傳列舉常量的序數（它在列舉宣告中的位置，其中初始常量序數為零）
static <T extends Enum> T valueOf(Class enumType, String name)
回傳帶指定名稱的指定列舉型別的列舉常量
values()此方法雖然在JDK檔案中查不到，但是每個列舉類都具有該方法，它用于遍歷列舉的所有列舉值

package cn.cxy.exec;

import org.junit.Test;

import java.util.Arrays;

public class TestScore {

    //測驗列舉的常用方法
    @Test
    public void test3() {
        //01-回傳當前列舉值的名稱
        System.out.println(Score.B.name());//B
        System.out.println(Score.B.toString());//B

        //02-列印當前列舉值在列舉類中宣告的順序
        System.out.println(Score.B.ordinal());//1,第2個列舉值

        /*使用場景：
         * 實際開發中表單提交過來的值是字串型別，需要驗證此字串是否是我們定義的列舉值
         * 如果可以轉換，說明提交的字串沒有問題，是我們預先定義好的列舉值
         * 如果不可以轉換，說明提交過來的字串有誤,會報非法引數例外，沒有這個列舉值*/
        //03-將字串轉成對應的列舉型別，注意這個型別必須是已有的列舉值
        //String str = "Cc";//IllegalArgumentException: No enum constant cn.tedu.oop.Score.Cc
        String str = "C";
        Score score = Score.valueOf(Score.class, str);
        System.out.println(score);
        //將字串轉成列舉型別的方式2，此種推薦，簡單
        System.out.println(Score.valueOf(str));

        Score[] values = Score.values();
        System.out.println(Arrays.toString(values));

    }
}

//1.使用enum關鍵字定義列舉類
enum Score {
    //2.列出本類的多個列舉物件
    A("100-80") {
        //7.給每個列舉物件實作剛剛步驟6定義的抽象方法
        public String localeScore() {
            return "優";
        }
    }, B("79-60") {
        public String localeScore() {
            return "中";
        }
    }, C("59-0") {
        public String localeScore() {
            return "差";
        }
    };
    //3.定義一個私有的屬性，封裝每個物件對應的分數
    private final String score;

    //4.定義一個私有的建構式
    private Score(String score) {
        this.score = score;
    }

    //5.定義一個輸出成績的抽象方法
    public abstract String localeScore();

    //6.定義一個公共的獲取成績的方法
    public String getScore() {
        return this.score;
    }
}

注意1：如果列舉類中只有一個物件，則可以看做單例模式的一種實作方式

enum A {//相當于定義了一個類 class A;
    A;//相當于創建了這個類唯一的一個物件new A(); 類似于單例設計模式
}

注意2：JDK5中擴展了switch陳述句，除了可以接收byte short char int ,還可以接收列舉型別

7 作業需求：

撰寫一個關于星期幾的列舉WeekDay
要求：列舉值：MON,TUE,WED,THR,FRI,SAT,SUN
該列舉要有一個方法，呼叫該方法回傳中文格式的星期幾

package cn.tedu.oop;

import org.junit.Test;

public class Demo2 {
    @Test
    public void test(){
        //6.1拿到指定的列舉名
        System.out.println(WeekDay.MON);//MON
        //6.2拿到指定的列舉名對應的值
        System.out.println(WeekDay.MON.getValue());//星期一
    }
}
//1.定義列舉類
enum WeekDay {
    //2.定義列舉類中的列舉與其對應的值
    MON("星期一"), TUE("星期二"), WES("星期三"), THR("星期四"), FRI("星期五"), SAT("星期六"), SUN("星期日");
    //3.定義列舉類中的私有屬性
    private String day;
    //4.定義列舉類的建構式
    private WeekDay(String day) {
        this.day = day;
    }
    //5.定義列舉類的方法，并獲取列舉對應的值
    public String getValue(){
        return this.day;
    }
}