枚举类

这种实例有限而且固定的类，在Java里称为枚举类。例如：季节类，它只有4个对象，还有行星类目前只有8个对象。

5.9.1 手动实现枚举类

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整数
2. 没有命名空间：
3. 打印输出的意义不明确：1很难猜测出代表春天。

5.9.2 枚举类入门

Java5新增一个enum关键字（和class、interface关键字差不多），用以定义枚举类。
枚举类是一种特殊的类，它一样有自己的成员变量、方法，可以实现一个或者多个接口，也可以定义自己的构造器。
但是枚举类还是和普通类有简单区别：

• 枚举类可以实现一个或多个接口，使用enum定义的枚举类默认继承了java.lang.Enum类，而不是默认继承Object类，因此枚举类不能显式继承其他父类。其中java.lang.Enum类实现了java.lang.Serializable和java.lang.Comparable两个接口。
• 使用Enum定义，非抽象的枚举类默认会使用final修饰，所以不能派生子类
• 枚举类的构造器只能使用private，如果省略了构造器的访问控制符，则默认使用private，
• 枚举类的所有实例必须在枚举类的第一行显式列出，否则这个枚举类永远都不能产生实例，列出这些实例时，系统会自动添加public staic final修饰，无须显式添加
  枚举类默认提供了一个values()方法，该方法可以很方便地遍历所有的枚举类

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

EnumTest.java

package code;
public class EnumTest{
    public void judge(SeasonEnum e){
        //switch语句里的表达式可以是枚举类
        switch(e){
            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);
    }
}

java.lang.Enum类中提供了如下的几个方法，所有枚举类可以直接使用这些方法：

• int compareTo(E o ):该方法用于与指定枚举对象比较顺序，同一个枚举实例只能与相同类型的枚举实例进行比较，如果该枚举对象位于指定枚举对象之后，则返回正整数，如果该枚举对象位于指定枚举对象之前，则返回负整数，否则返回零。
• String name()：返回此枚举实例的名称，，这个名称就是定义枚举类时列出的所有 枚举类之一，但是大多数情况下使用toString()方法
• int ordinal()：返回枚举值在枚举类中的索引值
• String toString() :返回枚举常量的名称，与name方法相似，toString方法更常用
• public static

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

Gender.java

package code;
public enum Gender{
    MALE,FEMALE;
    public String name;
}

GenderTest.java

package code;
public class GenderTest{
    public static void main(String [] args){
        Gender g = Enum.valueOf(Gender.class,"FEMALE");
        g.name = "女";
        System.out.println(g + "代表:" + g.name);

    }
}

java应该把所有类设计成良好封装的类，所以不应该允许直接访问Gender类的name成员变量，而应该通过方法来控制对name的访问。
接下来的代码是改进后的设计
Gender.java

package code;
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("参数错误");
                }
                break;
            case FEMALE:
                if(name.equals("女")){
                    this.name = name;
                }else{
                    System.out.println("参数错误");
                }
                break;
        }
    }
    public String getName(){
        return this.name;
    }
}

GenderTest.java

package code;
public class GenderTest{
    public static void main(String [] args){
        Gender g = Enum.valueOf(Gender.class,"FEMALE");
        g.setName("女");
        System.out.println(g + "代表:" + g.name());
        g.setName("男");
        System.out.println(g + "代表：" + g.getName());
    }
}

FEMALE代表:FEMALE
参数错误
FEMALE代表：女

实际上这种做法依然不好，枚举类通常应该设计成不可变类，也就是说，它的成员变量值不应该允许改变，这样会更安全，而且代码更加简洁。因此建议将枚举类的成员变量都使用private final修饰。
如果将所有的成员变量都使用了final修饰符来修饰，所以必须在构造器里为这些成员变量指定初始值（或者在定义成员变量时指定默认值，或者在初始化块中指定初始值，但是这两种情况不常见），因此应该为枚举类显式定义带参数的构造器。
一旦为枚举类显式定义了带参数的构造器，列出枚举值时就必须对应地传入参数。

package code;
public enum Gender{
    MALE("男"),FEMALE("女");
    private final String name;
    private Gender(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }

当为Gender枚举类创建了一个Gender(String name)构造器之后，列出枚举类就是从MALE(“男”),FEMALE(“女”);这句代码完成，也就是说在枚举类中列出枚举类时，实际上就是调用构造器创建枚举类对象。只是这里无须使用new关键字，无须显式调用构造器。
等同于以下两句代码

public static final Gender MALE = new Gender("男");
public static final Gender FEMALE = new Gender("女");

5.9.4 实现接口的枚举类

枚举类和普通类一样可以实现一个或多个接口

package code;
public enum Gender2 implements GenderDesc{
    MALE("男"),FEMALE("女");
    private final String name;
    private Gender(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public void info(){
        System.out.println("这是一个用于定义性别的枚举类");
    }
} 

枚举类实现接口和普通类实现接口完全一样。
如果由枚举类来实现接口里的方法，则每个枚举值在调用该方法时都有相同的行为方式，（因为方法体完全一样）如果需要每个枚举值在调用该方法时呈现不同的行为方式，则可以让每个枚举值分别实现该方法，每个枚举值提供不同的实现方式，从而让不同的枚举值调用该方法时具有不同的行为方式。
示例如下：

package code;
public enum Gender2 implements GenderDesc{
    MALE("男"){
        public void info(){
            System.out.println("这个枚举值代表男性");
        }
    },FEMALE("女"){
        public void info(){
            System.out.println("这个枚举值代表女性");
        }
    };
    private final String name;
    private Gender2(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    /*public void info(){
        System.out.println("这是一个用于定义性别的枚举类");
    }*/
} 

上述代码中MALE和FEMALE后面的花括号部分实际上是一个类体部分，类似匿名内部类。在这种情况下，当创建MALE,FEMALE枚举值时，并不是直接创建Gender枚举类的实例，而是相当于创建了Gender的匿名子类的实例。所以括号内的只是枚举类的匿名内部子类。

并不是所有的枚举类都使用了final修饰，非抽象的枚举类才默认使用final修饰，对于一个抽象的枚举类，只要它包含抽象方法，他就是抽象枚举类，系统会默认使用abstract修饰。

5.9.5 包含抽象方法的枚举类

package code;
public enum Operation{
    PLUS{
        public double eval(double a ,double b){
            return (a+b);
        }
    },
    MINUS{
        public double eval(double a ,double b){
                return (a-b);
            }
    },
    TIMES{
        public double eval(double a ,double b){
            return (a*b);
        }
    },
    DIVIDE{
        public double eval(double a ,double b){
            return (a/b);
        }
    };
    public abstract double eval(double a,double b);
    public static void main(String [] args){
        System.out.println(Operation.PLUS.eval(3,4));
        System.out.println(Operation.MINUS.eval(3,4));
        System.out.println(Operation.TIMES.eval(3,4));
        System.out.println(Operation.DIVIDE.eval(3,4));
    }
}

7.0
-1.0
12.0
0.75

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