面向对象（五）— 枚举类、

枚举类

《疯狂Java讲义》学习笔记

什么是枚举类：
在某些情况下，一个类的对象是有限且固定的，比如季节类，它只有4个对象；行星类只有8个对象，这种实例有限且固定的类，被称为枚举类

package test;

    /*
    自定义枚举类
        通过 private 把构造器隐藏起来
        把这个类的所有可能实例 public static final 修饰的类变量来保存
        如果有必要，可以提供一些静态方法，允许其他程序根据特定参数来获取与之匹配的实例
    */

public class Season {
    private final String name;
    private final String desc;

    public static final Season SPRING = new Season("春天", "趁春踏青");
    public static final Season SUMMER = new Season("夏天", "夏日炎炎");
    public static final Season FALL = new Season("秋天", "秋高气爽");
    public static final Season WINTER = new Season("冬天", "围炉赏雪");

    //私有化构造器不允许自己创建季节对象
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public static Season getSeason(int seasonNum) {
        switch (seasonNum) {
            case 1:
                return SPRING;
            case 2:
                return SUMMER;
            case 3:
                return FALL;
            case 4:
                return WINTER;
            default:
                return null;
        }
    }

    // 只为name和desc提供getter方法
    public String getName() {
        return this.name;
    }

    public String getDesc() {
        return this.desc;
    }
}

使用 enum 定义枚举类

• Java5新增了一个关键字 enum （与 class，interface 关键字的地位相同），用于定义枚举类
• 枚举类是一种特殊的类，可以有自己的成员变量，方法，可以实现一个或多个接口，也可以定义自己的构造器
• 一个java源文件最多定义一个 public 访问权限的枚举类，且Java源文件也必须和该枚举类的类名相同
• 但枚举类不是普通的类，它与普通类有如下区别：
  ①、枚举类可以实现一个或者多个接口，使用 enum 定义的枚举类默认继承了 java.lang.Enum 类，而不是默认继承 Object 类，因此枚举类不能显示继承其他父类。其中 java.lang.Enum 实现了 java.lang.Serializable 和 java.lang.Comparable 接口
  ②、使用 enum 定义非抽象的枚举类默认会使用 final 修饰，因此枚举类不能派生子类
  ③、枚举类的构造器只能使用 private 访问控制符，如果省略了构造器的访问控制符，则默认使用 private 修饰；如果强制使用访问控制符，则只能使用 private 修饰符
  ④、枚举类的所有实例必须在第一行显示列出，否则这个枚举类永远不会产生实例。列出这些实例时，系统会自动添加 public static final 修饰，无需显示添加

public class Season {
    //使用enum关键字定义枚举类
    enum SeasonEnum {
        //定义枚举类需要显示的列出所有的枚举值，所有的枚举值使用 英文逗号 隔开，枚举值列举结束后使用英文分号作为结束，
        //这些值代表了枚举类所有可能的实例
        SPRING, SUMMER, FALL, WINTER;
    }

    //枚举类默认提供了一个values()方法，该方法可以很方便的遍历所有的枚举值
    //访问枚举类的实例：EnumClass.variable的形式（SeasonEnum.SPRING）
    public static void main(String[] args) {
        System.out.println(SeasonEnum.SPRING);
        //使用枚举类默认的values()方法，返回该枚举类的所有实例
        for (SeasonEnum s : SeasonEnum.values()) {
            System.out.println(s);
        }
    }

    //JDK1.5增加了对枚举类的扩展，switch的控制表达式可以是任何枚举类型，当控制表达式是枚举类型时，
    //后面的case表达式中的值可以直接使用枚举值的名字，无需添加枚举值类作为限定
    public static 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;
        }
    }
}

java.lang.Enum 类中提供的常用方法

//所有的枚举类都默认继承了 java.lang.Enum 类，所以枚举类可以直接使用 java.lang.Enum 类所包含的方法
int compareTo(E o)：//该方法用于返回指定枚举类对象的比较顺序，同一个枚举实例只能和相同类型的枚举实例进行比较；
//如果该枚举类型位于指定枚举类型之后，则返回正整数；如果该枚举类型位于指定枚举类型之前，则返回负整数；否则返回0
//使用compareTo()方法，比较枚举对象顺序
System.out.println(SeasonEnum.SPRING.compareTo(SeasonEnum.FALL));//返回-2
System.out.println(SeasonEnum.SPRING.compareTo(SeasonEnum.SPRING));//返回0
System.out.println(SeasonEnum.FALL.compareTo(SeasonEnum.SPRING));//返回2
 
public final String name()：//该方法用于返回枚举实例的名称，应该优先考虑使用 toString() 方法
System.out.println(SeasonEnum.SPRING.name());//SPRING
public final int ordinal()：//该方法返回枚举值在枚举类中的索引值（就是枚举值在枚举声明中的位置，第一个枚举值的索引为0）
System.out.println(SeasonEnum.SUMMER.ordinal());//1
public String toString()
//toString():返回枚举常量的名称，与name方法相似，但toString（）方法更常用
System.out.println(SeasonEnum.SUMMER.toString());
public static < T extends Enum < T > > T valueOf( Class<T> enumType , String name )
//该方法用于返回指定枚举类中指定名称的值
System.out.println(Enum.valueOf(SeasonEnum.class, "SPRING"));//SPRING

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

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

//下面定义一个Gender枚举类，该枚举类包含了一个 name 实例变量
public class TestGender {
    public static void main(String[] args) {
        //通过Enum的valueOf() 方法来获取指定枚举类的枚举值
        Gender g = Enum.valueOf(Gender.class, "FEMALE");
        g.name = "女";
        //直接访问枚举值的name实例变量
        System.out.println(g.name);
    }
}

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

上面定义Gender类和普通的类没有太大的区别，区别只是产生Gender对象的方式不同，枚举类的实例只能是枚举值，而不是随意的通过new关键字来创建枚举对象

	//下面的语句编译不通过
	// Enum types cannot be instantiated
	Gender g2 = new Gender();

//正如前面提到的，Java应该把所有的类设计成良好封装的类，所以不应该允许直接访问Gender类的name成员变量，
// 而是应该通过方法来控制对name的访问。可按照如下代码改进Gender类的设计
public class TestGender {
    public static void main(String[] args) {
        //通过Enum的valueOf() 方法来获取指定枚举类的枚举值
        Gender g = Enum.valueOf(Gender.class, "FEMALE");
        g.setName("男");//提示参数设置错误
        Gender g2 = Enum.valueOf(Gender.class, "MALE");
        g2.setName("男");
        //直接访问枚举值的name实例变量
        System.out.println(g2.getName());
    }
}

enum Gender {
    MALE, FEMALE;
    //定义一个 private 修饰的变量
    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;
        }
    }

    public String getName() {
        return name;
    }
}

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

enum Gender2 {
    //此处的枚举值必须调用对应的构造器来创建
    MALE("男"), FEMALE("女");
    //上面一行代码相当于下面的两行
    // public static final Gender2 MALE = new Gender2("男");
    // public static final Gender2 FEMALE = new Gender2("女");

    private final String name;

    //枚举类的构造器只能使用 private 修饰
    private Gender2(String name) {
        this.name = name;
    }

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

实现接口的枚举类

枚举类可以实现一个或者多个接口，与普通类实现一个或多个接口一样，枚举类实现一个或者多个接口时，也需要实现该接口所包含的方法。

public class EnumTest {
    public static void main(String[] args) {
        Gender g1 = Gender.FEMALE;
        Gender g2 = Gender.MALE;
        //如下 g1 ，g2 执行结果完全一样
        g1.info();
        g2.info();
    }
}

interface GenderDesc {
    void info();
}

enum Gender implements GenderDesc {
    //此处的枚举值必须调用对应的构造器来创建
    MALE("男"), FEMALE("女");

    private final String name;

    //枚举类的构造器只能使用 private 修饰
    private Gender(String name) {
        this.name = name;
    }

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

    @Override
    public void info() {
        System.out.println("这是一个用于定义性别的枚举类");
    }
}

以上的g1 ，g2 执行结果完全一样，如果需要每个枚举值在调用该方法时呈现出不同的行为方式，则可以让每个枚举值分别实现该方法，每个枚举值提供不同的实现
将上面程序改成如下：

public class EnumTest {
    public static void main(String[] args) {
        Gender g1 = Gender.FEMALE;
        Gender g2 = Gender.MALE;
        g1.info();// 性别为女
        g2.info();// 性别为男
    }
}

interface GenderDesc {
    void info();
}

enum Gender implements GenderDesc {
    //此处的枚举值必须调用对应的构造器来创建
    MALE("男") {//花括号部分实际上是一个类体部分

        @Override
        public void info() {
            System.out.println("性别为男");
        }
    }, FEMALE("女") {
        @Override
        public void info() {
            System.out.println("性别为女");
        }
    };

    private final String name;

    //枚举类的构造器只能使用 private 修饰
    private Gender(String name) {
        this.name = name;
    }

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

上面的代码看起来有些奇怪：当创建 MALE 和 FEMALE 两个枚举值时，后面又跟了一对花括号，这对花括号里又包含了一个 info() 方法的定义。如果读者还记得匿名内部类的语法的话，花括号实际上就是一个类体的部分；
当创建MALE、FEMALE枚举值时，并不是创建 Gender 枚举类的实例，而是相当于创建 Gender 匿名子类的实例，因为粗体括号部分实际上是匿名内部类的类体部分
所以这个部分的代码语法与前面介绍的匿名内部类的语法大致相似，只是他依然是枚举类的匿名内部子类。