枚举

枚举 : 把数据控制在一定范围内

2016-10-08 14:52:20

传统方式定义枚举

public class Student {

    private String name;

    private Grade grade;//ABCDE

    public String getName() {
        return name;
    }

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

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }

}

//传统方式定义枚举
class Grade{

    private Grade(){};//构造方法私有化,外部就不能常见此类的实例
    public static Grade A = new Grade();
    public static Grade B = new Grade();
    public static Grade C = new Grade();
    public static Grade D = new Grade();
    public static Grade E = new Grade();


}

public class Demo {

    public static void main(String[] args) {

    Student student = new Student();
    student.setGrade(Grade.A);

    }

}

 

 

新增枚举类型

//JDK1.5以后新增了枚举类型

enum Grade{
    A,B,C,D,E
}

 

枚举类型中定义构造方法和普通字段

class Grade{
    private String value;//A:100-90 B:89-80 C:79-70 D:69-60 E:<60

    //构造方法私有化,外部就不能常见此类的实例
    private Grade(String value){
        this.value = value;
    };
    public static Grade A = new Grade("100-90");
    public static Grade B = new Grade("89-80");
    public static Grade C = new Grade("79-70");
    public static Grade D = new Grade("69-60");
    public static Grade E = new Grade("<60");

    public String getValue() {
        return value;
    }
}

enum Grade{

    A("100-90"),B("89-80"),C("79-70"),D("69-60"),E("<60");

    private String value;//A:100-90 B:89-80 C:79-70 D:69-60 E:<60

    //可以定义构造函数,但必须是私有的
    private Grade(String value){

        this.value = value;
    }

    public String getValue() {
        return value;
    }


}

 

枚举类型中定义普通方法

//传统方式定义枚举
class Grade{
    private String value;//A:100-90 B:89-80 C:79-70 D:69-60 E:<60
    //构造方法私有化,外部就不能常见此类的实例
    private Grade(String value){
        this.value = value;
    };
    public static Grade A = new Grade("100-90"){

        //匿名内部类,覆盖了父类中的方法
        public String toString1(){
            return "100-90";
        }
    };
    public static Grade B = new Grade("89-80");
    public static Grade C = new Grade("79-70");
    public static Grade D = new Grade("69-60");
    public static Grade E = new Grade("<60");

    public String getValue() {
        return value;
    }

    public String toString1(){
        return null;
    }

}

enum Grade{

    A("100-90"){

        //匿名内部类,覆盖了父类中的方法
        public String toString1(){
            return "100-90";
        }
    },B("89-80"){

        //匿名内部类,覆盖了父类中的方法
        public String toString1(){
            return "89-80";
        }
    },C("79-70"){

        //匿名内部类,覆盖了父类中的方法
        public String toString1(){
            return "79-70";
        }
    },D("69-60"){

        //匿名内部类,覆盖了父类中的方法
        public String toString1(){
            return "69-60";
        }
    },E("<60"){

        //匿名内部类,覆盖了父类中的方法
        public String toString1(){
            return "<60";
        }
    };

    private String value;//A:100-90 B:89-80 C:79-70 D:69-60 E:<60

    //可以定义构造函数,但必须是私有的
    private Grade(String value){

        this.value = value;
    }

    public String getValue() {
        return value;
    }

    //还可以定义普通方法和字段

    public abstract String toString1();
}

public class Demo {

    public static void main(String[] args) {

    System.out.println(Grade.A.toString1());

    }

}

 

带抽象方法的枚举

enum Grade {

    A("100-90") {

        // 匿名内部类,覆盖了父类中的方法
        public String toString1() {
            return "100-90";
        }

        public String toLocalString() {

            return "优秀";
        }
    },
    B("89-80") {

        // 匿名内部类,覆盖了父类中的方法
        public String toString1() {
            return "89-80";
        }

        public String toLocalString() {

            return "良好";
        }
    },
    C("79-70") {

        // 匿名内部类,覆盖了父类中的方法
        public String toString1() {
            return "79-70";
        }

        public String toLocalString() {

            return "中等";
        }
    },
    D("69-60") {

        // 匿名内部类,覆盖了父类中的方法
        public String toString1() {
            return "69-60";
        }

        public String toLocalString() {

            return "一般";
        }
    },
    E("<60") {

        // 匿名内部类,覆盖了父类中的方法
        public String toString1() {
            return "尚需努力";
        }

        public String toLocalString() {

            return "优秀";
        }
    };

    private String value;// A:100-90 B:89-80 C:79-70 D:69-60 E:<60

    // 可以定义构造函数,但必须是私有的
    private Grade(String value) {

        this.value = value;
    }

    public String getValue() {
        return value;
    }

    // 还可以定义普通方法和字段

    public abstract String toString1();

    public abstract String toLocalString();
}

 

自定义枚举是java.Lang.Enum的子类

public class Demo {

    public static void main(String[] args) {

//      System.out.println(Grade.A.name());// A
//      System.out.println(Grade.B.ordinal());// 枚举值的顺序,从0开始

        //列出所有的枚举值
        Grade[] values = Grade.values();
        for (Grade grade : values) {
            System.out.println(grade.name());
        }

        //String 转换为枚举类型
        Grade grade = Grade.valueOf("A");
        System.out.println(grade.toLocalString());

    }

}