列舉是什麼？

       列舉型別是指由一組固定的常量組成合法值的型別。列舉型別是解決常量int的另一種解決方案。

列舉型別的簡單示例：

public enum AlarmPoints {STAIR1,STAIR2,LOBBY,OFFICE1,OFFICE2,OFFICE3,OFFICE4,BATHROOM,UTILITY,KITCHEN}

列舉的優勢：

     列舉型別是真正的final.所以客戶端即不能建立，也不能對它進行擴充套件，因此很可能沒有例項，而只有申明過的列舉常量。換句話說，列舉型別是例項受控的。它們是單例的泛型化。

     列舉型別提供檢查異常。

     命名直觀，可讀性強。

     實現了Comparable和Serialicable 介面。

簡單列舉型別對於大多數列舉型別來說，已經夠用了，但有的時候你可能需要更多的方法。有的時候，你需要將本質不同的行為和每個常量聯絡起來。比如，編寫4中計算方式的列舉型別：

public enum Operation {
    PLUS,
    MIMUS,
    TIMES,
    DIVIDE;
    double apply(double x,double y){

        switch(this){
            case PLUS: return x + y;
            case MIMUS: return x - y;
            case TIMES: return x * y;
            case DIVIDE:return x / y;
        }
        throw new AssertionError("Unknown op:" + this);
    }
}
 

這段程式碼看似可行，只是不太好看，如果沒有throw語句，就沒有辦法編譯通過，但是實際上不可能知道最後的語句。最糟糕的是，如果你添加了新的列舉型別，而switch中卻沒有新增，編譯異常通過，執行卻會出錯。有一種解決方案：

public enum Operation {
    PLUS{
        @Override
        double apply(double x, double y) {
            return  x + y;
        }
    },
    MIMUS {
        @Override
        double apply(double x, double y) {
            return x - y;
        }
    },
    TIMES {
        @Override
        double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE {
        @Override
        double apply(double x, double y) {
            return x / y;
        }
    };
    abstract double apply(double x,double y);
}
 

在這中寫法下，你新增新常量，編譯器會提醒你重寫抽象方法，你也必須重寫抽象方法；

它可以和特定的符號結合起來：

public enum Operation {
    PLUS("+"){
        @Override
        double apply(double x, double y) {
            return  x + y;
        }
    },
    MIMUS ("-"){
        @Override
        double apply(double x, double y) {
            return x - y;
        }
    },
    TIMES ("*"){
        @Override
        double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE("/") {
        @Override
        double apply(double x, double y) {
            return x / y;
        }
    };
    private final String sysmbol;

    Operation(String sysmbol){
        this.sysmbol = sysmbol;
    }

    @Override
    public String toString() {
        return sysmbol;
    }

    abstract double apply(double x, double y);
}

    public static void main(String[] args) {
        double x = 2.0;
        double y = 4.0;
        Arrays.asList(values()).forEach(o->{
            System.out.printf("%f %s %f = %f%n",x,o,y,o.apply(x,y));
        });
    }

2.000000 + 4.000000 = 6.000000
2.000000 - 4.000000 = -2.000000
2.000000 * 4.000000 = 8.000000
2.000000 / 4.000000 = 0.500000

打印出了很工整的表單。

列舉型別有一個valueOf(String name)方法，可以將字串轉換成真是列舉型別，由於覆蓋了toString 方法，所以編寫一個fromString方法；

    private static final Map<String,Operation> stringToEnum = new HashMap<>();
    static {
        Arrays.asList(Operation.values()).forEach(o-> stringToEnum.put(o.toString(),o));
    }

    public static Operation fromString(String symbol){
        return stringToEnum.get(symbol);
    }

特定於常量的方法實現中有一個美中不足的地方，它們使得列舉常量中共享程式碼變得更加困難了。比如，考慮用一個列舉表示薪資包中的工作天數。這個列舉中有一個方法，根據給定某工人的基本工資以及當天的工作時間，來計算它當天的報酬。在五個工作日中，超過8個小時算加班，加班有額外工資，週六，周天，全天算加班。

public enum PayrollDay {
    MON,TUE,WED,THU,FRI,SAT,SUN;
    private static final int HOUTS_PER_SHIFT = 8;

    public double get(final int hours,double payRate){
        double base = hours * payRate;
        double over;
        switch (this){
            case SAT:case SUN:
                over = hours * payRate * 0.5;
                default: over = hours >= HOUTS_PER_SHIFT ?
                        (hours - HOUTS_PER_SHIFT) * payRate * 0.5: 0;
        }
        return base + over;
    }
}

程式碼非常簡潔，但是確難以維護，如果某人有一個工作日，確實放假，但是又忘記新增switch,程式依然可以執行，只是結果不正確而已。

你真正想要的就是每當新增一個列舉常量是，就強制選擇一種加班報酬策略，又一種很好的方法可以實現這一點，新增一個列舉策略，來實現對加班工資的計算，雖然這種方式沒有那麼簡潔，但卻更加安全，也更加靈活：

public enum PayrollDay {
    MON(PayType.WEEKDAY),TUE(PayType.WEEKDAY),WED(PayType.WEEKDAY),
    THU(PayType.WEEKDAY),FRI(PayType.WEEKDAY),
    SAT(PayType.WEEKEND),SUN(PayType.WEEKEND);
    //支付方式
    private final PayType payType;
    //初始化payType
    PayrollDay(PayType payType){
        this.payType = payType;
    }
    //計算
    public double pay(final int hours,double payRate){
        return payType.get(hours,payRate);
    }


    enum PayType{
        WEEKDAY {
            @Override
            double overGet(int hours, double payRate) {
                return hours >= HOUTS_PER_SHIFT ?
                        (hours - HOUTS_PER_SHIFT) * payRate * 0.5: 0;
            }
        },
       WEEKEND {
           @Override
           double overGet(int hours, double payRate) {
               return  hours * payRate * 0.5;
           }
       };
       private static final int HOUTS_PER_SHIFT = 8;

       abstract double overGet(final int hours,double payRate);
        public double get(final int hours,double payRate){
            double base = hours * payRate;
            double over = overGet(hours,payRate);
            return base + over;
        }
   }
}

測試：

    public static void main(String[] args) {
        double s = SUN.pay(10,10);
        double s1 = MON.pay(10,10);
        double s2 = MON.pay(7,10);
        System.out.println(s + "..." + s1 + "..." + s2);
    }

150.0...110.0...70.0

列舉中的switch語句適合於給外部的列舉型別增加特定於常量的行為，或改變，或替換

public class Demo{
    public static Operation inverse(Operation o){
        switch (o){
            case PLUS: return MIMUS;
            case MIMUS:return PLUS;
            case TIMES:return DIVIDE;
            case DIVIDE:return TIMES;
            default: throw new AssertionError("Unknow o:" + o);
        }
    }
}

這裡使用了靜態匯入