java 枚举类型

枚举的实质是什么？

枚举继承了ENUM类，枚举类型的每一个成员都以该类型的一个实例,而且默认的都是声明为public static final的 ，而且枚举里的每一个对象 就是当前枚举实例化的对象枚举里面所有的方法，里面的每个对象都可以调用

enum中的方法：

A.ordinal()用来返回枚举值在枚举类中的顺序。

B.compareTo ()比较两个枚举值的顺序，返回顺序之差。

C.values(),静态方法，返回包含一个全部枚举值的数组。

D.toString()，返回枚举常量的名称

E.valueOf()，返回指定没弄成的枚举类型的枚举常量。 

 

 先看个简单示例：

enum FruitEnum {
    APPLE(1), ORANGE(2);    //    调用构造函数来构造枚举项

    private int value = 0;

    private FruitEnum(int value) {    //    必须是private的，否则编译错误
        this.value = value;
    }

    public static FruitEnum valueOf(int value) {    //    手写的从int到enum的转换函数
        switch (value) {
        case 1:
            return APPLE;
        case 2:
            return ORANGE;
        default:
            return null;
        }
    }

    public int value() {
        return this.value;
    }
}

public static void main(String[] args) {
    System.out.println(FruitEnum.APPLE.value());    //    1
    System.out.println(FruitEnum.ORANGE.value());    //   2
    System.out.println(FruitEnum.valueOf(1));        //  FruitEnum.APPLE
    System.out.println(FruitEnum.valueOf(2));        //  FruitEnum.ORANGE
}

 

下面就是网络上的各种版本的用法了：
用法一：常量

public enum Color {  
  RED, GREEN, BLANK, YELLOW  
} 

用法二：switch

enum Signal {
        GREEN, YELLOW, RED
    }

    public class TrafficLight {
        Signal color = Signal.RED;

        public void change() {
            switch (color) {
            case RED:
                color = Signal.GREEN;
                break;
            case YELLOW:
                color = Signal.RED;
                break;
            case GREEN:
                color = Signal.YELLOW;
                break;
            }
        }
    }

用法三：向枚举中添加新方法

public enum Color {
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
        // 成员变量
        private String name;
        private int index;

        // 构造方法
        private Color(String name, int index) {
            this.name = name;
            this.index = index;
        }

        // 普通方法
        public static String getName(int index) {
            for (Color c : Color.values()) {
                if (c.getIndex() == index) {
                    return c.name;
                }
            }
            return null;
        }

        // get set 方法
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getIndex() {
            return index;
        }

        public void setIndex(int index) {
            this.index = index;
        }
    }

用法四：覆盖枚举的方法

public class Test {
    public enum Color {
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
        // 成员变量
        private String name;
        private int index;

        // 构造方法
        private Color(String name, int index) {
            this.name = name;
            this.index = index;
        }

        // 覆盖方法
        @Override
        public String toString() {
            return this.index + "_" + this.name;
        }
    }

    public static void main(String[] args) {
        System.out.println(Color.RED.toString());
    }
}

用法五：实现接口

public interface Behaviour {
        void print();

        String getInfo();
    }

    public enum Color implements Behaviour {
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);
        // 成员变量
        private String name;
        private int index;

        // 构造方法
        private Color(String name, int index) {
            this.name = name;
            this.index = index;
        }

        // 接口方法

        @Override
        public String getInfo() {
            return this.name;
        }

        // 接口方法
        @Override
        public void print() {
            System.out.println(this.index + ":" + this.name);
        }
    }

 

实例

public interface DateInfo {
     public String getDateInfo();
 }

public enum Season2 implements DateInfo {
    
    SPRING("春天","春风又绿江南岸"){
        @Override
        public String getDateInfo() {
            return "2-5";
        }
    },
    SUMMER("夏天","映日荷花别样红"){
        @Override
        public String getDateInfo() {
            return "5-8";
        }
    },
    FALL("秋天","秋水共长天一色"){
        @Override
        public String getDateInfo() {
            return "8-11";
        }
    },
    WINTER("冬天","窗寒西岭千秋雪"){
        @Override
        public String getDateInfo() {
            return "11-2";
        }
    },;
    
    private String name;
    private String desc;
    
    private Season2(String name,String desc){
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

/*    @Override 改为利用匿名内部类重写的方法更酷些
    public String getDateInfo() {
        System.out.println(this.toString().equals("SPRING"));
        return null;
    }  */    
}

Season2类继承接口DateInfo


public class TestSeason {

    public static void main(String[] args) {

//        Season SPRING = Season.SPRING;
//        System.out.println(SPRING);
//        System.out.println(Season2.SPRING);
        for(Season2 s:Season2.values()){
//            System.out.println(s);
//            System.out.println(s.toString().equals("SPRING"));
            System.out.println(s.getDateInfo());    
        }
        
        String str = "WINTER";
        Season2 s = Season2.valueOf(Season2.class, str);
        System.out.println(s.getName()+" "+s.getDesc());
    }
}

TestSeason测试类