34、枚举详解

知识点介绍
1、枚举可以实现一个或多个接口。枚举默认继承于java.lang.Enum类，而不是Object类。Enum类实现了java.lang.Serializable和java.lang.Comparable两个接口
2、使用enum定义、非抽象的枚举默认会使用final修饰，因此枚举不能派生子类

3、枚举类的构造器只能使用private访问控制符

4、枚举类的所有势力必须在枚举类的第一行显示列出

下面是一个简单的枚举应用

public class Test{
    public static void main(String[] args) {
        SessonEnum e=Enum.valueOf(SessonEnum.class, "Spring");
        System.out.println(e.name());
    }
}

enum SessonEnum{
    Spring,Summer,Fall,Winter;
}

枚举类的成员变量、方法和构造器

 1 public class Hello {
 2     public static void main(String[] args) {
 3         SessonEnum e=Enum.valueOf(SessonEnum.class, "Spring");
 4         System.out.println(e.getName());
 5     }
 6 }
 7
 8
 9 enum SessonEnum{
10     Spring("春"),Summer("夏"),Fall("秋"),Winter("冬");
11     private  final String name;
12     private SessonEnum(String name){
13         this.name=name;
14     }
15     public String getName(){
16         return name;
17     }
18 }

实现接口的枚举

1、由枚举类来实现接口里的方法——所有枚举值实现接口都是调用方法都有相同的行为

 1 interface SessonInfo{
 2     void info();
 3 }
 4
 5 enum SessonEnum implements SessonInfo {
 6
 7     Spring("春"),Summer("夏"),Fall("秋"),Winter("冬");
 8
 9
10     private  final String name;
11     private SessonEnum(String name){
12         this.name=name;
13     }
14     public String getName(){
15         return name;
16     }
17     @Override
18     public void info() {
19         System.out.println("这里是公用接口的实现");
20
21     }
22 }
23
24 public class Test{
25     public static void main(String[] args) {
26         SessonEnum spring=Enum.valueOf(SessonEnum.class, "Spring");
27         SessonEnum summer=SessonEnum.Summer;
28         spring.info();
29         summer.info();
30     }
31 }

输出结果：

这里是公用接口的实现
这里是公用接口的实现

2、分别由每个枚举值来实现接口

 1 interface SessonInfo{
 2     void info();
 3 }
 4
 5 enum SessonEnum implements SessonInfo {
 6
 7     Spring("春"){
 8         @Override
 9         public void info() {
10             System.out.println("这里是春季");
11         }
12     },Summer("夏"){
13         @Override
14         public void info() {
15             System.out.println("这里是夏季");
16         }
17
18     },Fall("秋"){
19         @Override
20         public void info() {
21             System.out.println("这里是秋季");
22         }
23     },Winter("冬"){
24         @Override
25         public void info() {
26             System.out.println("这里是冬季");
27         }
28     };
29
30
31     private  final String name;
32     private SessonEnum(String name){
33         this.name=name;
34     }
35     public String getName(){
36         return name;
37     }
38 }
39
40 public class Hello {
41     public static void main(String[] args) {
42         SessonEnum spring=Enum.valueOf(SessonEnum.class, "Spring");
43         SessonEnum summer=SessonEnum.Summer;
44         spring.info();
45         summer.info();
46     }
47 }

输出结果：

这里是春季
这里是夏季

枚举抽象类

假设有一个Operation枚举类，它的4个枚举值PLUS、MINUS、TIMES、DIVIDE分别代表加、减、乘、除4种运算，该枚举类需要定义一个eval（）方法来完成计算

 1 public class Test{
 2     public static void main(String[] args) {
 3         System.out.println("1+2="+Operation.PLUS.eval(1, 2));
 4         System.out.println("5-3="+Operation.MINUS.eval(5, 3));
 5         System.out.println("3*4="+Operation.TIMES.eval(3, 4));
 6         System.out.println("10-2="+Operation.DIVIDE.eval(10, 2));
 7     }
 8 }
 9
10 enum Operation{
11     PLUS{
12         public double eval(double x, double y) {
13             return x+y;
14         }
15     },
16     MINUS{
17         public double eval(double x, double y) {
18             return x-y;
19         }
20     },
21     TIMES{
22         @Override
23         public double eval(double x, double y) {
24             return x*y;
25         }
26     },
27     DIVIDE{
28         @Override
29         public double eval(double x, double y) {
30             return x/y;
31         }
32     };
33     public abstract double eval(double x,double y);
34 }

输出结果：

1+2=3.0
5-3=2.0
3*4=12.0
10-2=5.0