枚举

1 定义 public enum Grade
和 定义普通的类 没有什么区别 Garde 现在就是一个枚举类 是一个类
2 定义 枚举类的对象
A,B,C;//这里就是一些枚举值 可以看作是静态的属性，A BC 就是Grade的对象 已经算是new 好了
枚举类里面可以有构造函数 其他 属性 方法 等….

public enum Grade {
    //下面其实就是创建了枚举对象 调用构造函数
  A("100-90"),B("90-80"),C("80-70"),D("70-60"),E("60-1");
    //枚举里面可以有构造函数 但是必须是私有的
    //定义一个普通的变量
    String score;
    //枚举的构造函数
    private Grade(String score){
        //枚举的构造函数 可以作用于ABCDE对象
        this.score=score;
    }
    //定义枚举的方法 就是普通方法
    public String getScore() {
        return score;
    }
    public void setScore(String score) {
        this.score = score;
    }

}

public class Student {
  String name;
  Grade grade;//定义一个枚举的成员属性
  Student(String name,Grade grade){
      this.name=name;
      this.grade=grade;
  }
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;
}
@Override
public String toString() {
    return "Student [name=" + name + ", grade=" + grade + "]";
}

}

public class TestStudent1 {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Student s1=new Student("王帅",Grade.A);//枚举类型 可以直接 类名.对象
        System.out.println(s1.getGrade().getScore());//得到枚举对象 然后调用枚举对象的方法
    }
//输出 100-90
}

枚举可以当做switch的判别变量

  Grade a=Grade.A;//相当于 A a=new A();
        switch(a){
        case A:
            System.out.println("AAAAAAAAAA");
            break;
        case B:
            System.out.println("AAAAAAAAAA");
            break;
        case C:
            System.out.println("AAAAAAAAAA");
            break;
            ｝

枚举里面 定义抽象方法

public enum Grade {
    //下面其实就是创建了枚举对象 调用构造函数 里面写上抽象方法的实现类
    A("100-90") {
        public String toLoaclGrade() {
            return "优秀";
        }
    },
    B("90-80") {
        public String toLoaclGrade() {
            return "优秀";
        }
    },
    C("80-70") {
        public String toLoaclGrade() {
            return "优秀";
        }
    },
    D("70-60") {
        public String toLoaclGrade() {
            return "优秀";
        }
    },
    E("60-1") {
        public String toLoaclGrade() {
            return "优秀";
        }
    };// 这里就是一些枚举值 可以看作是静态的属性， Grade相当于类 实际是对象（Grade对象） 不是简单的变量
    //枚举里面可以有构造函数 但是必须是私有的
    //定义一个普通的变量
    String score;
    private Grade(String score){
        //枚举的构造函数 可以作用于ABCDE对象
        this.score=score;
    }
    //定义枚举的方法 就是普通方法
    public String getScore() {
        return score;
    }
    public void setScore(String score) {
        this.score = score;
    }
    //定义一个抽象方法
    //一个类里面有抽象方法 可以直接new 类 然后重写里面的方法 枚举也类似
    public abstract String toLoaclGrade();
/*
 * 关于枚举类型 上面 对象里面使用匿名内部类的说明：
 * 我们以前 普通类 这样写 匿名内部类的 new 抽象类(){这里写上 抽象方法}
 *  abstract class Person {
    public abstract void eat();
}

public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}
枚举类型的A BCDE 这些本来就是 对象了，所以可以直接 后面写上 抽象方法

 */
}

     枚举里面常用的方法 所有的自定义的枚举类都继承自java.lang.Enum 
      name() 
     ordinal() //返回枚举对象的序号 从0 开始
      valueof(Class enumClass) 是把参数的类型，转换为枚举类型
      values() 返回枚举对象的数组

  String s="A";//转换后的A 必须枚举有该对象 
        if(Grade.valueOf(s)==Grade.A){
            System.out.println("OK");

 for(Grade m:Grade.values()){
        System.out.println(m.name());//ABCDE
        System.out.println(m);//等价
        System.out.println(m.ordinal());//01234  从0开始
        }