java枚舉介紹

枚舉類型 :枚舉常量的一組集合，包含者一些操做方法,枚舉類是不可變的，一般用做單實例操做。

    包含的方法 

        自帶靜態方法  values（） 返回枚舉類中枚舉常量數組 (按枚舉常量聲明的順序返回)

         toString()方法    返回枚舉常量名稱。

         靜態方法valueOf(String name)   返回指定名稱（name指的是默認toString方法返回的值，即類型常量的名稱）的枚舉常量

         ordinal()  返回指定枚舉常量在枚舉類型中聲明的位置，位置從0開始哦

枚舉類型中  每個枚舉常量都要實現，枚舉類中的抽象方法,枚舉常量就是一個靜態變量。所以下面代碼枚舉類型常量須要放在自定義靜態代碼塊以前

    案例以下：

package com.effectJava.Chapter3;

import java.util.HashMap;
import java.util.Map;

public enum Operation {

    PLUS("+") {
        @Override
        int apply(int a, int b) {
            return a + b;
        }
    }, MINUS("-") {
        @Override
        int apply(int a, int b) {
            return a - b;
        }
    }, MULTI("*") {
        @Override
        int apply(int a, int b) {
            return a * b;
        }
    }, DIVID("/") {
        @Override
        int apply(int a, int b) {//測試代碼不必處理可能的異常
            return a / b;
        }
    };

    //    自定義的valueOf方法
    private static final Map<String, Operation> maps;

    static {
        System.out.println("Initi Static Block");
        maps = new HashMap<>();
        for (Operation operation : Operation.values()) {
            maps.put(operation.symbol, operation);
        }

    }

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


    private final String symbol;

    Operation(String symbol) {
        System.out.println(symbol);
        this.symbol = symbol;
    }

    abstract int apply(int a, int b);

    //   把symbol變爲枚舉常量的惟一標識後，
   //最好定義一個fromString(String symbol)方法返回symbol惟一標識的枚舉類型
    public static void main(String... args) {
        System.out.println(Operation.PLUS.apply(1, 2));
//        Operation.valueOf("ss");

        System.out.println(Operation.fromString("+"));
    }
}

 

    java 程序初始化順序

  1.父類靜態變量   2.父類靜態代碼塊 3.子類靜態變量 4.子類靜態代碼塊 5.父類非靜態變量 6.父類非靜態代碼塊，7.父類構造器，8.子類非靜態變量 9.子類非靜態代碼塊 10.子類構造器

 

序列索引實現香草分類

package com.effectJava.Chapter3;

import sun.misc.SharedSecrets;

import java.util.EnumMap;
import java.util.HashSet;
import java.util.Set;

public class Herb {
    public enum Type {ANNUAL, PERENNIAL, BIENNIAL,}

    private final String name;
    private final Type type;

    Herb(String name, Type type) {
        this.name = name;
        this.type = type;
    }

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


//    對植物進行分類

    public static void main(String... args) {

        Herb herbs[] = new Herb[]{new Herb("herb1", Type.PERENNIAL), new Herb("herb2", Type.ANNUAL), new Herb("herb3", Type.ANNUAL), new Herb("herb4", Type.BIENNIAL)};
        //1.經過枚舉常量的位置序號來對植物的類別分類位置
        // 構造類別數組
        Set<Herb>[] her = (Set<Herb>[]) new Set[Type.values().length];

        for (int i = 0; i < her.length; i++) {
            her[i] = new HashSet<Herb>();
        }
//        對植物進行分類
        for (Herb herb : herbs) {
            her[herb.type.ordinal()].add(herb);
        }
        for (int i = 0; i < her.length; i++) {
            System.out.printf("%s : %s%n", Herb.Type.values()[i], her[i]);
        }
        System.out.println(SharedSecrets.getJavaLangAccess().getEnumConstantsShared(Type.class));


//EnumMap分類  對每種香草分類，
//       2. 使用EnumMap來實現植物分類
        System.out.println(" 使用EnumMap來實現植物分類");
        EnumMap<Type, Set<Herb>> typeSetEnumMap = new EnumMap<>(Type.class);
        for (Herb.Type t : Herb.Type.values()) {
            typeSetEnumMap.put(t, new HashSet<Herb>());
        }
        for (Herb h : herbs) {
            typeSetEnumMap.get(h.type).add(h);
        }
        System.out.println(typeSetEnumMap);
    }

}

 

EnumMap狀態轉移兩種實現

package com.effectJava.Chapter3;

//轉移關係
public enum Phase {
    SOLID, LIQUID, GAS;

    public enum Transition {
        MELT, FREEZE, BOIL, CONDENSE, SUBLIME, DEPOSIT;
        private static final Transition[][] transitions = {{null, MELT, SUBLIME}, {FREEZE, null, BOIL}, {DEPOSIT, CONDENSE, null}};

        public static Transition from(Phase src, Phase dest) {
            return transitions[src.ordinal()][dest.ordinal()];
        }
    }
}

 

優化以後的代碼

package com.effectJava.Chapter3;

import java.util.EnumMap;
import java.util.Map;

//經過 Map<起始階段,Map<目標階段,階段過渡>>  來表示轉移關係
public enum PhaseModify {

    SOLID,LIQUID,GAS;

    public enum Transition {
        MELT(SOLID, LIQUID),
        FREEZE(LIQUID, SOLID),
        BOIL(LIQUID, GAS),
        CONDENSE(GAS, LIQUID),
        SUBLIME(SOLID, GAS),
        DEPOSIT(GAS, SOLID);

        private final PhaseModify src;
        private final PhaseModify dst;

        Transition(PhaseModify src, PhaseModify dst) {
            this.src = src;
            this.dst = dst;
        }

        private static final Map<PhaseModify, Map<PhaseModify, Transition>> map = new EnumMap<PhaseModify, Map<PhaseModify, Transition>>(PhaseModify.class);

        static {
            for (PhaseModify p : PhaseModify.values()) {
                map.put(p, new EnumMap<PhaseModify, Transition>(PhaseModify.class));
            }
            for (Transition trans : Transition.values()) {
                map.get(trans.src).put(trans.dst, trans);
            }
        }
        public static Transition from(Phase src, Phase dst) {
            return map.get(src).get(dst);
        }



    }

}