Java枚举类详解-优快云博客

参考资料
定义一个枚举类

参考资料

[1]. 疯狂Java讲义（第三版）李刚

定义一个枚举类

使用关键字enum 定义一个枚举类

/**
 * 枚举类 季节
 */
public  enum  SeasonEnum {
    /**
     * 春夏秋冬
     */
    SPRING, SUMMER, FALL, WINTER;
}

不设置枚举的默认值

/**
 * 使用枚举类
 */
public class EnumTest {

    /**
     * 测试方法
     * @param s
     */
    public void judge(SeasonEnum s)
    {
        // switch语句里的表达式可以是枚举值
        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)
    {
        // 枚举类默认有一个values()方法，返回该枚举类的所有实例
        for (SeasonEnum s : SeasonEnum.values())
        {
            System.out.println(s);
        }
        // 使用枚举类实例时，可通过EnumClass.variable形式来访问
        new EnumTest().judge(SeasonEnum.SPRING);


    }
}

为枚举类设置一个临时值，不加限制版

枚举值无默认值时

public enum Gender {
    MALE, FEMALE;
    /**
     * 非静态变量
     */
    public String name3;
}

需要手动设置枚举类的值，这种方式不常用

public class GenderTest {
    public static void main(String[] args)
    {
        // 通过Enum的valueOf()方法来获取指定枚举类的枚举值
        Gender g = Enum.valueOf(Gender.class, "FEMALE");
        // 直接为枚举值的name实例变量赋值
        g.name = "女";
        // 直接访问枚举值的name实例变量
        System.out.println(g + "代表：" + g.name);
    }
}

为枚举类设置一个临时值，增加限制版

Java应该把所有的类设计成良好封装的类，所以不允许直接访问Gender类的name成员变量，而是通过方法来控制对name的访问，下面改进一下上面的枚举类和方法。
枚举类

public enum Gender {
    /**
     * 枚举值
     */
    MALE, FEMALE;
    /**
     * 非静态变量
     */
    private String name;

    public void setName(String name)
    {
        switch (this)
        {
            case MALE:
                if (name.equals("男"))
                {
                    this.name = name;
                }else{
                    System.out.println("参数错误");
                    return;
                }
                break;
            case FEMALE:
                if (name.equals("女"))
                {
                    this.name = name;
                }else{
                    System.out.println("参数错误");
                    return;
                }
                break;
                default:
        }
    }

    /**
     * 获取name
     * @return
     */
    public String getName() {
        return this.name;
    }
}

调用

public class GenderTest {
    public static void main(String[] args)
    {
        // 通过Enum的valueOf()方法来获取指定枚举类的枚举值
        Gender g = Enum.valueOf(Gender.class, "FEMALE");
        // 直接为枚举值的name实例变量赋值
        g.setName("女");
        System.out.println(g + "代表：" + g.getName());
        // 此时如果再设置name值时，则会报错
        g.setName("男");
        System.out.println(g + "代表：" + g.getName());
    }
}

为枚举类设置一个固定值

枚举类通常应该设计成不可变类，也就是说，它的成员变量值不应该允许改变，这样会更安全，因此建议将枚举类的成员变量都使用private final 修饰，并且要指定初始值。代码如下：
枚举类：

public enum Gender {
    /**
     * 枚举值
     */
    MALE("男"), FEMALE("女");
    /**
     * name
     */
    private final String name;
    // 构造器，默认为private修饰
     Gender(String name)
    {
        this.name = name;
    }

    /**
     * 获取name
     * @return
     */
    public String getName()
    {
        return this.name;
    }
}

调用

// 通过Enum的valueOf()方法来获取指定枚举类的枚举值
Gender g = Enum.valueOf(Gender.class, "FEMALE");
// 直接为枚举值的name实例变量赋值
System.out.println(g.getName());

使用枚举类实现一个接口

枚举类可以实现一个或多个接口，与普通类实现一个或多个接口完全一样，枚举类实现一个或多个接口时，也需要实现该接口所包含的方法，需要为枚举值增加匿名内部类部分，就是枚举值的花括号部分。
接口类

/**
 * 枚举类需要实现的接口
 */
public interface GenderDesc {
    /**
     * 需要实现的info方法
     */
    void info();
}

枚举类

/**
 * 实现了接口的枚举类
 */
public enum Gender implements GenderDesc{
    /**
     * 此处的枚举值必须调用对应构造器来创建
     * 这两个枚举值的花括号相当于枚举类的匿名内部类
     */
    MALE("男")
            // 花括号部分实际上是一个类体部分
            {
                @Override
                public void info()
                {
                    System.out.println("这个枚举值代表男性");
                }
            },
    FEMALE("女")
            {
                @Override
                public void info()
                {
                    System.out.println("这个枚举值代表女性");
                }
            };
    /**
     * name
     */
    private final String name;

    /**
     * 枚举类的构造器默认使用private修饰
     * @param name
     */
     Gender(String name)
    {
        this.name = name;
    }

    /**
     * 设置name
     * @return
     */
    public String getName()
    {
        return this.name;
    }

    /**
     * 增加下面的info()方法，实现GenderDesc接口必须实现的方法
     */
    @Override
    public void info()
    {
        System.out.println(
                "这是一个用于用于定义性别的枚举类");
    }
}

调用

public class GenderTest {
    public static void main(String[] args)
    {
        // 通过Enum的valueOf()方法来获取指定枚举类的枚举值
        Gender g = Enum.valueOf(Gender.class, "FEMALE");
        // 直接为枚举值的name实例变量赋值
        System.out.println(g.getName());
        // 调用覆盖的方法
        g.info();
    }
}

包含抽象方法的枚举类

枚举类里定义抽象方法时不能使用abstract关键字将枚举类定义成抽象类（因为系统自动会为它添加abstract关键字），但因为枚举类需要显示创建枚举值，而不是作为父类，所以定义每个枚举值时必须为抽象方法提供实现，否则将出现编译错误。

/**
 * 枚举类Operation
 */
public enum Operation
{
    /**
     * 下面每个枚举值都用匿名内部类实现了抽象方法eval
     */
    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
            {
                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(3, 4));
        System.out.println(Operation.MINUS.eval(5, 4));
        System.out.println(Operation.TIMES.eval(5, 4));
        System.out.println(Operation.DIVIDE.eval(5, 4));
    }
}