【JAVA】浅谈java枚举类

一、什么情况下使用枚举类？

　　有的时候一个类的对象是有限且固定的，这种情况下我们使用枚举类就比较方便？

二、为什么不用静态常量来替代枚举类呢？

    public static final int SEASON_SPRING = 1;
    public static final int SEASON_SUMMER = 2;
    public static final int SEASON_FALL = 3;
    public static final int SEASON_WINTER = 4;

　　枚举类更加直观，类型安全。使用常量会有以下几个缺陷：

　　1. 类型不安全。若一个方法中要求传入季节这个参数，用常量的话，形参就是int类型，开发者传入任意类型的int类型值就行，但是如果是枚举类型的话，就只能传入枚举类中包含的对象。

　　2. 没有命名空间。开发者要在命名的时候以SEASON_开头，这样另外一个开发者再看这段代码的时候，才知道这四个常量分别代表季节。

三、枚举类入门

　　先看一个简单的枚举类。

package enumcase;

public enum SeasonEnum {
    SPRING,SUMMER,FALL,WINTER;
}

1. enum和class、interface的地位一样
2. 使用enum定义的枚举类默认继承了java.lang.Enum，而不是继承Object类。枚举类可以实现一个或多个接口。
3. 枚举类的所有实例都必须放在第一行展示，不需使用new 关键字，不需显式调用构造器。自动添加public static final修饰。
4. 使用enum定义、非抽象的枚举类默认使用final修饰，不可以被继承。
5. 枚举类的构造器只能是私有的。

四、枚举类介绍

　　枚举类内也可以定义属性和方法，可是是静态的和非静态的。

package enumcase;

public enum SeasonEnum {
    SPRING("春天"),SUMMER("夏天"),FALL("秋天"),WINTER("冬天");

    private final String name;

    private SeasonEnum(String name)
    {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

　  实际上在第一行写枚举类实例的时候，默认是调用了构造器的，所以此处需要传入参数，因为没有显式申明无参构造器，只能调用有参数的构造器。

　　构造器需定义成私有的，这样就不能在别处申明此类的对象了。枚举类通常应该设计成不可变类，它的Field不应该被改变，这样会更安全，而且代码更加简洁。所以我们将Field用private final修饰。

五、枚举类实现接口

　　枚举类可以实现一个或多个接口。与普通类一样，实现接口的时候需要实现接口中定义的所有方法，若没有完全实现，那这个枚举类就是抽象的，只是不需显式加上abstract修饰，系统化会默认加上。

　　

package enumcase;

public enum Operation {
    PLUS{

        @Override
        public double eval(double x, double y) {
            return x + y;
        }

    },
    MINUS{

        @Override
        public double eval(double x, double y) {
            return x - y;
        }

    },
    TIMES{

        @Override
        public double eval(double x, double y) {
            return x * y;
        }

    },
    DIVIDE{

        @Override
        public double eval(double x, double y) {
            return x / y;
        }

    };

    /**
     * 抽象方法，由不同的枚举值提供不同的实现。
     * @param x
     * @param y
     * @return
     */
    public abstract double eval(double x, double y);

    public static void main(String[] args) {
        System.out.println(Operation.PLUS.eval(10, 2));
        System.out.println(Operation.MINUS.eval(10, 2));
        System.out.println(Operation.TIMES.eval(10, 2));
        System.out.println(Operation.DIVIDE.eval(10, 2));
    }
}

　　Operatio类实际上是抽象的，不可以创建枚举值，所以此处在申明枚举值的时候，都实现了抽象方法，这其实是匿名内部类的实现，花括号部分是一个类体。我们可以看下编译以后的文件。

　　aaarticlea/png;base64,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" alt="" />

　　共生成了五个class文件，这样就证明了PLUS,MINUS,TIMES,DIVIDE是Operation的匿名内部类的实例。

六、switch语句里的表达式可以是枚举值

　　Java5新增了enum关键字，同时扩展了switch。

package enumcase;

public class SeasonTest {
    public void judge(SeasonEnum s)
    {
        switch(s)
        {
        case SPRING:
            System.out.println("春天适合踏青。");
            break;
        case SUMMER:
            System.out.println("夏天要去游泳啦。");
            break;
        case FALL:
            System.out.println("秋天一定要去旅游哦。");
            break;
        case WINTER:
            System.out.println("冬天要是下雪就好啦。");
            break;
        }
    }

    public static void main(String[] args) {
        SeasonEnum s = SeasonEnum.SPRING;
        SeasonTest test = new SeasonTest();
        test.judge(s);
    }
}

　　case表达式中直接写入枚举值，不需加入枚举类作为限定。