【Java學習筆記】枚舉類型

作者：gnuhpc
出處：http://www.cnblogs.com/gnuhpc/

java.lang.Enum > 使用enum定義。

類如：

public class EnumDemo {
    enum Edge {
        TOP, BOTTOM, LEFT, RIGHT//定義了一個enum類型的執行個體，一個枚舉類型除了那些由枚舉常量定義的執行個體外沒有任何其他執行個體。
    };
    public static void main(String arg[]) {
        Edge edge1 = Edge.LEFT;
        Edge edge2 = Edge.LEFT;
      //由於每個枚舉類型的執行個體在一個程式中只能有一個，所以我們可以使用==來判斷是否相同。
        System.out.println("Can we use == to judge equals:"+ (edge1 == edge2));
        int i = edge1.ordinal();
        System.out.println("The value of i: " + i);
        System.out.println(edge1);
        String str = "";
        switch(edge1) {
    /*  case Edge.TOP: This is wrong*/
        case TOP: str = "The top edge"; break;
        case BOTTOM: str = "The bottom edge"; break;
        case LEFT: str = "The left edge"; break;
        case RIGHT: str = "The right edge"; break;
        }
        System.out.println(str);
    }
這就解決了switch不能對字串進行的缺點了。注意：枚舉類型也是類，裡面的成員實際上是靜態final類型的枚舉類型執行個體。

為了更好的理解枚舉類型，我們用普通類類比一下該枚舉類 ：

public abstract class WeekDay {
    private int workhours;
    private boolean work;
    private WeekDay(int workhours, boolean work) {
        this.workhours = workhours;
        this.work = work;
    }
    protected abstract WeekDay getNextDay();
    public static final WeekDay MONDAY = new WeekDay(8,true){
         public WeekDay getNextDay() {
                return TUESDAY;
            }
         @Override
        public String toString() {
            return "MONDAY";
        }
    };
    public static final WeekDay TUESDAY = new WeekDay(8,true){
         public WeekDay getNextDay() {
                return WEDNESDAY;
            }
         @Override
            public String toString() {
                return "TUESDAY";
            }
    };
    public static final WeekDay WEDNESDAY = new WeekDay(8,true){
         public WeekDay getNextDay() {
                return THURSDAY;
            }
         @Override
            public String toString() {
                return "WEDNESDAY";
            }
    };
    public static final WeekDay THURSDAY = new WeekDay(8,true){
         public WeekDay getNextDay() {
                return FRIDAY;
            }
         @Override
            public String toString() {
                return "THURSDAY";
            }
    };
    public static final WeekDay FRIDAY = new WeekDay(8,true){
         public WeekDay getNextDay() {
                return SATURDAY;
            }
         @Override
            public String toString() {
                return "FRIDAY";
            }
    };
    public static final WeekDay SATURDAY = new WeekDay(4,true){
         public WeekDay getNextDay() {
                return SUNDAY;
            }
         @Override
            public String toString() {
                return "SATURDAY";
            }
    };
    public static final WeekDay SUNDAY = new WeekDay(0,false){
         public WeekDay getNextDay() {
                return MONDAY;
            }
         @Override
            public String toString() {
                return "SUNDAY";
            }
    };
    private static void showDay(WeekDay d) {
        if(d.isWeekday()) {
            System.out.println(d + " is a weekday and has " +
                    d.getHours() + " working hours.");
        } else {
            System.out.println(d + " is not a weekday and has " +
                    d.getHours() + " working hours.");
        }
    }
    private int getHours() {
        // TODO Auto-generated method stub
        return workhours;
    }
    private boolean isWeekday() {
        return work;
    }
    public static void main(String[] args) {
        WeekDay day = WeekDay.FRIDAY;
        showDay(day);
        day = WeekDay.FRIDAY.getNextDay();
        showDay(day);
        day = day.getNextDay();
        showDay(day);
    }
}

因此，有以下更複雜的應用：

public enum Day {
MONDAY (8,true){//首先使用了子類繼承的匿名類方式進行了對父類建構函式的，並且在子類中完成了父類的抽象方法
        public Day getNextDay() {
            return TUESDAY;
        }
    },
    TUESDAY (8,true){
        public Day getNextDay() {
            return WEDNESDAY;
        }
    },
    WEDNESDAY (8,true){
        public Day getNextDay() {
            return THURSDAY;
        }
    },
    THURSDAY (8,true){
        public Day getNextDay() {
            return FRIDAY;
        }
    },
    FRIDAY (8,true){
        public Day getNextDay() {
            return SATURDAY;
        }
    },
    SATURDAY (4,false){
        public Day getNextDay() {
            return SUNDAY;
        }
    },
    SUNDAY (0,false){
        public Day getNextDay() {
            return MONDAY;
        }
    };
    private int hours;
    private boolean weekday;
Day(int workHours,boolean weekdayFlag) {
        hours = workHours;
        weekday = weekdayFlag;
    }
    private abstract Day getNextDay();
    public int getHours() {
        return(hours);
    }
    public boolean isWeekday() {
        return(weekday);
    }
    private static void showDay(Day d) {
        if(d.isWeekday()) {
            System.out.println(d + " is a weekday and has " +
                    d.getHours() + " working hours.");
        } else {
            System.out.println(d + " is not a weekday and has " +
                    d.getHours() + " working hours.");
        }
    }
    public static void main(String arg[]) {
        Day day;
        day = Day.TUESDAY;
        showDay(day);
        day = Day.SATURDAY;
        showDay(day);
        day = Day.THURSDAY.getNextDay();
        showDay(day);
    }
}

注意：

1.注意枚舉類型不能定義為abstract或者final。

2.枚舉類中定義了抽象方法，但是枚舉類卻沒有執行個體去實現這個抽象方法，這樣會報錯。

3.一個枚舉類型除非包含至少一個枚舉常量帶有class body，否則就是隱式final的。

4.嵌套 （在一個類中定義的枚舉）的枚舉類型是隱式static的，若顯示賦予就會出錯。

5.EnumSet包含了許多靜態方法用來指定不同的集合建立和讀取方式。

 

作者：gnuhpc
出處：http://www.cnblogs.com/gnuhpc/