Java - 枚举

传统模式实现Enum

[java] view
plain copy

package com.itlwc;  

  

class MyEnum {  

    public static final int BOY = 0;  

    public static final int GIRL = 1;  

}  

  

class Student {  

    String name;  

    int age;  

  

    public Student(String name, int age) {  

        this.name = name;  

        if (age != 0 && age != 1) {  

            String errorMsg = "非法性别参数" + age + ",应该为1或者0";  

            throw new IllegalArgumentException(errorMsg);  

        } else {  

            this.age = age;  

        }  

    }  

}  

  

public class Test {  

    public static void main(String[] args) {  

        new Student("lwc", 0);//虽然不报错,但没有使用预定义的常量,逻辑错误  

        new Student("nxj", MyEnum.GIRL);  

    }  

}  

使用传统模式实现枚举几点不足

[plain] view
plain copy

必须单独声明每一个常量,并且赋值  

接受枚举类型合法必须由开发人员自己开发  

参数合法性不能在编译时直接指出,只能在运行时看到  

使用枚举类型实现

[java] view
plain copy

package com.itlwc;  

  

enum MyEnum {  

    MALE, FAMALE  

}  

  

class Student {  

    String name;  

    MyEnum me;  

  

    public Student(String name, MyEnum me) {  

        this.name = name;  

        this.me = me;  

    }  

}  

  

public class Test {  

    public static void main(String[] args) {  

        new Student("lwc", 200);//直接报错  

        new Student("nxj", MyEnum.MALE);  

    }  

}  

使用枚举类型实现的优点

[java] view
plain copy

避免开发枚举值合法性代码,错误在编译时就会发现,提高了开发效率,避免了不必要的错误  

枚举(Enum)概述

[plain] view
plain copy

定义语法为  

    enum MyEnum{  

        MALE,FAMALE  

    }  

自定义枚举都继承java.lang.Enum(抽象类)  

枚举默认默认实现了java.lang.Comparable接口  

枚举成员默认都是pubilc static final的(非枚举值可以不是)  

枚举的成员就是枚举的实例,所以定义枚举类型之后,在编译时就能确定枚举类型有几个实例,  

    分别是什么,在运行期间再无法为枚举类型创建新的实例    

枚举不可以有public或者protected的构造函数,这样可以保证客户代码不能新建一个枚举的实例    

虽然枚举和类很相似,声明位置相同,但并不是一个类,他们最大的区别就是  

    类的对象是不确定的,new几次就生成几个,枚举的对象在编译期已经确定好了      

Enum遍历

[java] view
plain copy

package com.itlwc;  

  

enum Week {  

    // 编译期已经确定下来Week有8个实例  

    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, STR {  

        // 重写了toString方法  

        public String toString() {  

            return "输入参数有误,参数值范围在0~6";  

        }  

    };  

}  

  

public class Test {  

    public static void main(String[] args) {  

        // 引用枚举里面的值  

        System.out.println(Week.SUNDAY);  

        System.out.println("----------------------------");  

        // 静态方法values()返回定义枚举中枚举值的一个数组  

        for (Week w : Week.values()) {  

            // ordinal()返回枚举值的位置  

            System.out.println(w + "-->所在的顺序是" + w.ordinal());  

        }  

        System.out.println("----------------------------");  

        System.out.println(new Test().getWeek(7));  

    }  

  

    public Week getWeek(int i) {  

        switch (i) {  

        case 0:  

            return Week.SUNDAY;  

        case 1:  

            return Week.MONDAY;  

        case 2:  

            return Week.TUESDAY;  

        case 3:  

            return Week.WEDNESDAY;  

        case 4:  

            return Week.THURSDAY;  

        case 5:  

            return Week.FRIDAY;  

        case 6:  

            return Week.SATURDAY;  

        default:  

            return Week.STR;  

        }  

    }  

}  

/* 

打印结果: 

    SUNDAY 

    ---------------------------- 

    SUNDAY-->所在的顺序是0 

    MONDAY-->所在的顺序是1 

    TUESDAY-->所在的顺序是2 

    WEDNESDAY-->所在的顺序是3 

    THURSDAY-->所在的顺序是4 

    FRIDAY-->所在的顺序是5 

    SATURDAY-->所在的顺序是6 

    输入参数有误,参数值范围在0~6-->所在的顺序是7 

    ---------------------------- 

    输入参数有误,参数值范围在0~6 

*/  

Enum的构造器

简单构造器

[java] view
plain copy

package com.itlwc;  

  

public enum MyEnum {  

    RED(), GREEN(), BLUE();  

    // 简单构造器  

    MyEnum() {  

    }  

  

    public static void main(String[] args) {  

        MyEnum c = MyEnum.BLUE;  

        System.out.println(c);  

    }  

}  

/* 

打印结果: 

    BLUE 

*/  

复杂构造器

[java] view
plain copy

package com.itlwc;  

  

public enum MyEnum {  

    RED("红色"), GREEN("绿色"), BLUE("蓝色");  

    String name;  

    // 复杂构造器  

    MyEnum(String name) {  

        this.name = name;  

    }  

  

    public String getName() {  

        return name;  

    }  

  

    public void setName(String name) {  

        this.name = name;  

    }  

  

    public static void main(String[] args) {  

        MyEnum c = MyEnum.BLUE;  

        System.out.println(c.getName());  

        c.setName("设置的颜色");  

        System.out.println(c.getName());  

    }  

}  

/* 

打印结果: 

    蓝色 

    设置的颜色 

*/  

Enum实现接口

Enum实现接口,Enum中的每个对象都必须实现接口中的抽象方法

[java] view
plain copy

package com.itlwc;  

  

interface Info {  

    public String getColor();  

}  

  

public enum MyEnum implements Info {  

    RED {  

        public String getColor() {  

            return "红色";  

        }  

    },  

    GREEN {  

        public String getColor() {  

            return "绿色";  

        }  

    },  

    BLUE {  

        public String getColor() {  

            return "蓝色";  

        }  

    };  

    public static void main(String[] args) {  

        for (MyEnum c : MyEnum.values()) {  

            System.out.println(c.ordinal() + "-->" + c.name() + ":"  

                    + c.getColor());  

        }  

    }  

}  

/* 

打印结果: 

    0-->RED:红色 

    1-->GREEN:绿色 

    2-->BLUE:蓝色 

*/  

Enum中定义抽象方法

Enum中直接定义抽象方法,每个对象必须单独实现抽象方法

[java] view
plain copy

package com.itlwc;  

  

public enum MyEnum {  

    RED {  

        public String getColor() {  

            return "红色";  

        }  

    },  

    GREEN {  

        public String getColor() {  

            return "绿色";  

        }  

    },  

    BLUE {  

        public String getColor() {  

            return "蓝色";  

        }  

    };  

    public abstract String getColor();  

  

    public static void main(String[] args) {  

        for (MyEnum c : MyEnum.values()) {  

            System.out.println(c.ordinal() + "-->" + c.name() + ":"  

                    + c.getColor());  

        }  

    }  

}  

/* 

打印结果: 

    0-->RED:红色 

    1-->GREEN:绿色 

    2-->BLUE:蓝色 

*/  

EnumMap对Enum的支持

[java] view
plain copy

package com.itlwc;  

  

import java.util.EnumMap;  

import java.util.Map;  

  

enum Color {  

    RED, GREEN, BLUE;  

}  

  

public class Test {  

    public static void main(String[] args) {  

        EnumMap<Color, String> eMap = new EnumMap<Color, String>(Color.class);  

        eMap.put(Color.RED, "红色");  

        eMap.put(Color.GREEN, "绿色");  

        eMap.put(Color.BLUE, "蓝色");  

        for (Map.Entry<Color, String> mapE : eMap.entrySet()) {  

            System.out.println(mapE.getKey() + "-->" + mapE.getValue());  

        }  

    }  

}  

/* 

打印结果: 

    RED-->红色 

    GREEN-->绿色 

    BLUE-->蓝色 

*/  

EnumSet对Enum的支持

allOf()静态内部方法,用来将全部内容设置到集合中

[java] view
plain copy

package com.itlwc;  

  

import java.util.EnumSet;  

import java.util.Iterator;  

  

enum Color {  

    RED, GREEN, BLUE;  

}  

  

public class Test {  

    public static void main(String[] args) {  

        EnumSet<Color> eSet = EnumSet.allOf(Color.class);  

        Iterator<Color> iter = eSet.iterator();  

        while (iter.hasNext()) {  

            System.out.println(iter.next());  

        }  

    }  

}  

/* 

打印结果: 

    RED 

    GREEN 

    BLUE 

*/