Java学习——枚举类

枚举类

Java5新增加了一个enum关键字（它与class，interface关键字的地位相同），用以定义枚举类，枚举类时一种特殊的类，它一样可以拥有自己的属性和方法，可以实现一个或多个接口，也可以定义自己的构造器，一个Java源文件中最多只能定义一个public修饰发枚举类，且Java源文件的名字必须与public修饰 的枚举类的类名相同。

枚举类和普通类的区别：

　　1.枚举类可以实现一个或者多个接口，但是使用enum定义的枚举类是默认继承就java.long.Enum类，而不是默认继承Object类，因此枚举类不可显示的继承其他父类，其中               java.long.Enum实现了java.long.Serializable和java.long.Comparable两个接口。

　　2.使用enum定义非抽象的枚举类，默认是使用final修饰，因此枚举类是不能派生子类

　　3.枚举类的构造器是只能使用private修饰符。

　　4.枚举类的所有实例必须是写在枚举类的第一行显示列出，否则这个枚举类是永远不能产生实例，列出这些实例是系统会自动添加public static final修饰。

       枚举类提供了一个方法values（）方法，该方法可以很方便的遍历所有的枚举值。

package cn.it.demo02;

public enum SeasonEnum {
    //在第一行列出四个枚举实例
    SPRING,SUMMER,FALL,WINTER;
}

　　定义枚举类时，是需要显示的列出所有的枚举值，如上面的四个枚举实例，所有的枚举实例之间是可以使用英文逗号局分开，枚举值列举结束后以英文符号作为结束。

package cn.it.demo02;

public class EnumTest {
    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);
    }

}

　　从JDK1.5后，switch表达式中可以使用枚举类型，并且case后的值可以直接使用枚举值的名字，无需添加枚举类作为限定。

 所有的枚举类都继承了Enum类，所有枚举类可以直接使用Java.long.Enum类中的方法，java.long.Enum中定义了如下几个方法：

1. int compareTo(E o):该方法是用与与指定枚举对象比较循序，同一个枚举实例只能与同类型的枚举实例进行比较，如果该枚举对象位于指定枚举对象之后，就返回正整数，如果是在指定对象之前，就返回负整数，否则就返回一个0.
2. String nema()；返回此枚举实例的名称，这个名称就是定义枚举实例时所列出的所有枚举值之一，
3. int ordinal()：返回此枚举实例在枚举类中的索引值，就是枚举值在枚举类中定义的位置，第一个索引为0.
4. String toString():返回枚举常量的名称。

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

　　枚举类也是一种类，不过比较特殊，因此它一样可以定义成员变量，方法和构造器。

　　定义一个Gender类。

package cn.it.EnumDemo2;

public enum Gender {
    MALE, FEMALE;
    // 定义一个public修饰的实例变量
    public String name;
}

　　定义一个测试类

package cn.it.EnumDemo2;

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);
    }

}

　　使用枚举类和普通类是没有什么区别，唯一不同的是枚举类的实例只能是枚举值，而不是随意的通过new来创建一个枚举类对象，java应该把所有的类设计为良好的封装类，不能再类外直接访问类的成员变量，而是通过方法来控制成员变量的访问，否则会出现混乱的现象，例如，再把g.name设置为男的状态，可能就出现了FEMALE代表男的现象。

解决方法：

package cn.it.EnumDemo3;

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("nv")) {
                this.name = name;
            } else {
                System.out.println("参数错误！");
                return;
            }
            break;
        }
    }

    public String getName() {
        return this.name;
    }
}

package cn.it.EnumDemo3;

public class GenderTest {
    public static void main(String[] args) {
        Gender g = Gender.valueOf("FEMALE");
        g.setName("nv");
        System.out.println("g的名字：" + g.getName());
        System.out.println();
        // 设置错误的参数
        g.setName("男");
        System.out.println("g代表的是：" + g.getName());
    }

}

包含抽象方法的枚举类

　　假设有一个Operation类，他的四个枚举值用来分别代表加减乘除4种运算，该枚举类需要定义一个eval（）方法来完成计算，四个枚举值分别要为eval（）方法提供不同的实现。

　　

package cn.it.EnumDemo4;

/**
 * 包含抽象方法的枚举类
 * 
 * @author 12428
 *
 */
public enum Operation {
    PLUS {
        public double eval(double x, double y) {
            return x + y;
        }
    },
    MINUS {
        public double eval(double x, double y) {
            return x - y;
        }
    },
    Times {
        public double eval(double x, double y) {
            return x * y;
        }
    },
    DIVIDE {
        public double eval(double x, double y) {
            return x / y;
        }
    };

    // 为枚举类定义一个抽象方法
    // 这个抽象方法由不同的枚举值提供不同的实现
    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));
    }
}

　　编译上面的程序会生成5个class文件，Operation对应一个class文件，其他4个匿名内部子类分别对应一个文件，枚举类里定义抽象方法是不能使用abstract来修饰枚举类，因为系统会自动为枚举类添加abstract修饰符，因为枚举类需要显示的创建枚举值，而不是作为父类，所以定义每个枚举值时都要为抽象方法提供实现，否则编译出错。