枚举类（enum）

朱雀 2022-05-21 12:49 523阅读 0赞

【1】什么是枚举类？

  1. 实例（也叫对象）有限且固定不变的类，在Java里被称为枚举类。  
  4. 例如，季节类，它只有4个实例（春、夏、秋、冬），并且这4个实例不会改变。可以用枚举类来表示：
  6. public enum SeasonEnum{
  7.     SPRING,SUMMER,FALL,WINTER;
  8. }
  10. 枚举类是一种特殊的类，它一样可以有自己的成员变量、方法，可以实现一个或多个接口，也可以有自己的构造器。
  12. Java5新增了enum 关键字（与calss、interface 关键字用法相同），用来定义枚举类。

【2】为什么需要枚举类？

  1. （1）就如上面所说的，有些类的实例有限且固定，需要有一种特定且方便的方式来表示这种类。
  3. （2）使用枚举类可以使程序更加健壮，避免创建对象的随意性。
  5. （3）避免一些常量值的意义不明确（这个在下面会有具体示例）。

【3】枚举类的语法

  1. （1） 枚举类默认继承 java.lang.Enum 类，而不是 Object 类，因此枚举类不能显示继承其他父类。
  3. （2） 使用 enum 定义的非抽象的枚举类默认会使用 final 修饰，因此非抽象枚举类不能派生子类（即不能被继承）。
  5.          > final关键字回顾：final修饰的类不能被继承、修饰的方法不能被重写、修饰的属性其值不能改变。  
  8. （3） 枚举类的构造器只能使用 private 访问控制符，如果忽略访问控制符的话，则默认使用 private 修饰；如果强制指定其他的访问控制符（例如public、procted等）,则会报错。
  10. （4） 枚举类的所有实例必须在枚举类的第一行显示列出，否则这个枚举类永远都不可能产生实例。列出的这些实例，系统会自动给它们加上 public static final 修饰。枚举类的实例以逗号分隔，分号结束，这些列出的枚举值代表了该枚举类的所有可能的实例。

【4】枚举类的方法和用法

  1. （1）JDK 1.5中switch对枚举的扩展
  3.         switch( )的控制表达式（即括号中的条件）可以是任何枚举类型；当switch控制表达式使用枚举类型时，后面case表达式中的值可以直接使用枚举值的名字，而无需添加枚举类作为限定（不需要 \[ 也不能 \] 这样写：SeasonEnum.SPRING）。
  5. public enum SeasonEnum{
  6.     SPRING,SUMMER,FALL,WINTER;
  7. }
  9. public void test(SeasonEnum s){
  10.         switch(s)
  11.         {
  12.                 case SPRING:
  13.             System.out.println("春天到了");
  14.             break;
  15.         case SUMMER:
  16.             System.out.println("夏天到了");
  17.             break;
  18.         case FALL:
  19.             System.out.println("秋天到了");
  20.             break;
  21.         default:
  22.             System.out.println("冬天到了");
  23.         }
  24. }
  26. （2）枚举类默认有一个 values() 方法（不是继承来的），可以返回该枚举类的所有实例
  28. for(SeasonEnum s : SeasonEnum.values()){
  29.     System.out.println(s);
  30. }
  32.     System.out.pring(s)输出的结果和 System.out.pring(s.toString()) 是一样的，因为 System.out.pring(s) 实际上也是调用了 toString() 方法。
  34. （3）所有枚举类都继承了 java.lang.Enum 抽象类，所以枚举类可以直接使用 java.lang.Enum 类中所包含的方法
  36. //java.lang.Enum
  37. package java.lang;
  39. import java.io.Serializable;
  40. import java.io.IOException;
  41. import java.io.InvalidObjectException;
  42. import java.io.ObjectInputStream;
  43. import java.io.ObjectStreamException;
  45. public abstract class Enum<E extends Enum<E>>
  46.         implements Comparable<E>, Serializable {
  48.     private final String name;
  49.     public final String name() {
  50.         return name;
  51.     }
  52.     private final int ordinal;
  53.     public final int ordinal() {
  54.         return ordinal;
  55.     }
  56.     protected Enum(String name, int ordinal) {
  57.             this.name = name;
  58.             this.ordinal = ordinal;
  59.         }
  60.     public String toString() {
  61.         return name;
  62.     }
  63.     public final boolean equals(Object other) {
  64.         return this==other;
  65.     }
  66.     public final int hashCode() {
  67.         return super.hashCode();
  68.     }
  69.     protected final Object clone() throws CloneNotSupportedException {
  70.              throw new CloneNotSupportedException();
  71.         }
  72.         public final int compareTo(E o) {
  73.             Enum<?> other = (Enum<?>)o;
  74.             Enum<E> self = this;
  75.             if (self.getClass() != other.getClass() && self.getDeclaringClass() != other.getDeclaringClass())
  76.                 throw new ClassCastException();
  77.             return self.ordinal - other.ordinal;
  78.         }
  79.     public final Class<E> getDeclaringClass() {
  80.             Class<?> clazz = getClass();
  81.             Class<?> zuper = clazz.getSuperclass();
  82.             return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
  83.         }
  84.     public static <T extends Enum<T>> T valueOf(Class<T> enumType,String name) {
  85.             T result = enumType.enumConstantDirectory().get(name);
  86.             if (result != null)
  87.                 return result;
  88.             if (name == null)
  89.                 throw new NullPointerException("Name is null");
  90.             throw new IllegalArgumentException("No enum constant " + enumType.getCanonicalName() + "." + name);
  91.         }
  92.     protected final void finalize() { }
  93.         private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException {
  94.             throw new InvalidObjectException("can't deserialize enum");
  95.         }
  96.     private void readObjectNoData() throws ObjectStreamException {
  97.             throw new InvalidObjectException("can't deserialize enum");
  98.         }
  99. }
  101.     【\#\#\#】常用方法
  103.         > int compareTo(E o)：用于与指定枚举对象比较顺序，同一个枚举实例只能与相同类型的枚举实例进行比较。如果该枚举对象在指定枚举对象之后，则返回正整数；如果该枚举对象再指定枚举对象之前，则返回负整数；否则返回0。
  105. public enum SeasonEnum {
  106.     SPRING,SUMMER,FALL,WINTER;
  107. }
  109. System.out.println(SeasonEnum.SUMMER.compareTo(SeasonEnum.SPRING));  //1
  110. System.out.println(SeasonEnum.SUMMER.compareTo(SeasonEnum.SUMMER));  //0
  111. System.out.println(SeasonEnum.SUMMER.compareTo(SeasonEnum.FALL));    //-1
  112. System.out.println(SeasonEnum.SUMMER.compareTo(SeasonEnum.WINTER));  //-2
  114.     > String name()、String toString()：返回枚举常量（即实例）的名称，两个方法作用相似（可以看Enum类的源码进行比较），推荐使用 toString()。
  116. System.out.println(SeasonEnum.SPRING.name());        // SPRING
  117. System.out.println(SeasonEnum.SPRING.toString());    // SPRING
  119.     > ordinal()：返回枚举值（即实例）在枚举类中的索引值（即声明时的位置），第一个枚举值的索引值为 0。  
  122. System.out.println(SeasonEnum.SPRING.ordinal());    // 0
  123. System.out.println(SeasonEnum.SUMMER.ordinal());    // 1
  124. System.out.println(SeasonEnum.FALL.ordinal());      // 2
  125. System.out.println(SeasonEnum.WINTER.ordinal());    // 3
  127.     > public static <T extends Enum<T>> T valueOf(Class<T> enumType,String name)：静态方法，用于返回指定枚举类中指定名称的枚举值。名称必须与在该枚举类中声明枚举值时所使用的标识符完全匹配，不允许使用额外的空白字符。
  129. SeasonEnum seasonEnum = SeasonEnum.valueOf(SeasonEnum.class, SeasonEnum.FALL.toString());
  130. System.out.println(seasonEnum.toString());    //FALL

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

  1. 前面说过，枚举类是一种特殊的类，它一样可以有自己的成员变量、方法，可以实现一个或多个接口，也可以有自己的构造器。  
  4. 同时，枚举类的每个实例的成员变量的值（即对应的含义）应该是不能改变的；所以，建议将枚举类的成员变量都使用 pirvate final 修饰。
  6. 那么问题又来了，所有成员变量都使用 final 修饰，则必须使用下面三种方法为成员变量指定初始值：
  8.     （1）在构造器里为这些成员变量指定初始值。  
  11.     （2）在定义成员变量时指定默认值。  
  14.     （3）在初始化块中指定初始值。  
  17. 实际上，后面两种方式并不常用。所以，应该为枚举类显示定义带参数的构造器。一旦为枚举类显示定义了带参数的构造器，列举枚举值时就必须对应的传入参数。
  19. public enum Gender{
  20.     MALE("男"),FEMALE("女");
  21.     private final String name;
  22.     private Gender(String name){
  23.         this.name = name;
  24.     }
  25.     public String getName(){
  26.         return this.name;
  27.     }
  28. }
  30. 在第一行列出所有枚举值（实例）时，实际上就是调用了构造器创建枚举类对象；只是这里不需要使用 new 关键字，也无需显示调用构造器罢了。
  32. 在前面定义 SeasonEnum 时，没有传入参数，甚至没使用括号；是因为 SeasonEnum 里包含的是默认的无参构造器。

【6】实现接口的枚举类，不同枚举值（实例）可以提供不同的接口方法实现方式

  1. > 定义一个接口：  
  4. public interface GenderDesc{
  5.     void info();
  6. }
  8. > 枚举类实现该接口，并重写接口中的方法（普通方式）：
  10. public enum Gender implements GenderDesc{
  11.     MALE("男"),FEMALE("女");
  12.     private final String name;
  13.     private Gender(String name){
  14.         this.name = name;
  15.     }
  16.     public String getName(){
  17.         return this.name;
  18.     }
  19.     public void info(){
  20.         System.out.println("这是一个性别枚举类");
  21.     }
  22. }
  24.     如果由枚举类来实现接口里的方法，则每个枚举值在调用该方法时都有相同的行为方式。
  26. > 枚举类实现该接口，并重写接口中的方法（枚举类特有方式）：
  28. public enum Gender implements GenderDesc{
  29.     MALE("男"){
  30.     public void info(){
  31.               System.out.println("这个枚举值代表男性");
  32.         }
  33.     },
  34.     FEMALE("女"){
  35.     public void info(){
  36.             System.out.println("这个枚举值代表女性");
  37.         }
  38.     };
  39.     private final String name;
  40.     private Gender(String name){
  41.         this.name = name;
  42.     }
  43.     public String getName(){
  44.         return this.name;
  45.     }
  46. }
  48.     当每个枚举实例像上面这样分别实现该方法时，在枚举实例调用该方法时就会呈现出不同的行为方式。
  50.     上面这种在枚举值后面紧跟花括号的语法其实是创建匿名内部类的语法，花括号就是类体部分。当创建 MALE、FEMALE 枚举值时，并不是直接创建 Gender 枚举类的实例，而是相当于创建 Gender 的匿名子类的实例。编译上述程序，可以看到生成了 Gender.class、Gender$1.class、Gender$2.class 三个文件。  
  53.     并不是所有的枚举类都使用了 final 修饰，非抽象的枚举类才默认使用 final 修饰。对于一个抽象的枚举类（只要它包含了抽象方法，它就是抽象枚举类）而言，系统默认使用 abstract 修饰，而不是 final 。

【7】包含抽象方法的枚举类

  1. 需求：定义一个 Operation 枚举类，它有4个枚举值 PLUS，MINUS，TIMES，DIVIDE 分别代表加、减、乘、除 4种运算。该枚举类需要定义一个 eval() 方法来完成计算，且需要让4个枚举值对 eval() 方法各有不同的实现。  
  4. 方案1：可以按照上面的方式，先定义一个接口，接口中定义 eval() 方法，再由 Operation 实现该接口，且每个枚举值提供不同的 eval() 实现方式。  
  7. public interface OperationEval {
  8.     double eval(double x,double y);
  9. }
  11. public enum Operation implements OperationEval {
  12.     PLUS{
  13.         public double eval(double x,double y){
  14.             return x + y;
  15.         }
  16.     },
  17.     MINUS{
  18.         public double eval(double x,double y){
  19.             return x - y;
  20.         }
  21.     },
  22.     TIMES{
  23.         public double eval(double x,double y){
  24.             return x * y;
  25.         }
  26.     },
  27.     DIVIDE{
  28.         public double eval(double x,double y){
  29.             return x / y;
  30.         }
  31.     };
  32.     public static void main(String[] args){
  33.         System.out.println(Operation.PLUS.eval(4,2));   //6.0
  34.         System.out.println(Operation.MINUS.eval(4,2));  //2.0
  35.         System.out.println(Operation.TIMES.eval(4,2));  //8.0
  36.         System.out.println(Operation.DIVIDE.eval(4,2)); //2.0
  37.     }
  38. }
  40. 但是像上面这样做，还要多定义一个接口，多此一举。
  42. 方案2：可以直接在枚举类中定义一个抽象方法，然后让每个枚举值提供不同的实现方式，可以起到同样的效果。  
  45. public enum Operation2 {
  46.     PLUS{
  47.         public double eval(double x,double y){
  48.             return x + y;
  49.         }
  50.     },
  51.     MINUS{
  52.         public double eval(double x,double y){
  53.             return x - y;
  54.         }
  55.     },
  56.     TIMES{
  57.         public double eval(double x,double y){
  58.             return x * y;
  59.         }
  60.     },
  61.     DIVIDE{
  62.         public double eval(double x,double y){
  63.             return x / y;
  64.         }
  65.     };
  66.     public abstract double eval(double x,double y);
  67.     public static void main(String[] args){
  68.         System.out.println(Operation2.PLUS.eval(4,2));   //6.0
  69.         System.out.println(Operation2.MINUS.eval(4,2));  //2.0
  70.         System.out.println(Operation2.TIMES.eval(4,2));  //8.0
  71.         System.out.println(Operation2.DIVIDE.eval(4,2)); //2.0
  72.     }
  73. }
  75. 需要注意的是：枚举类里定义抽象方法时不能使用 abstract 关键字将枚举类定义成抽象类，因为系统会自动为它添加 abstract 修饰。但因为枚举类需要显示创建枚举值，而不是作为父类，所以定义每个枚举值时必须为抽象方法提供实现，否则将出现编译错误。

【8】枚举的使用场景

  1. 在开发中，枚举类可以用来定义一组固定的常量，并且可以清楚的展示常量所表示的含义。  
  4. 例如，可以定义一个系统登录渠道的枚举类：  
  7. public enum LoginChannelEnum {
  8.     ACCOUNT(0,"account","账号登录"),
  9.     EMAIL(1,"email", "邮箱登录"),
  10.     WECHAT(2,"wechat", "微信登录"),
  11.     QQ(3,"qq", "QQ登录");
  13.     private final int code;
  14.     private final String value;
  15.     private final String desc;
  17.     ChannelEnum(int code,String value, String desc) {
  18.         this.code = code;
  19.         this.value = value;
  20.         this.desc = desc;
  21.     }
  23.     ...
  24. }

发表评论

表情：
评论列表 （有 0 条评论，523人围观）

还没有评论，来说两句吧...

相关阅读

    相关 枚举(enum)

    前言 实际上，枚举类型是特殊的类，和C语言C++中的枚举不太一样，下面我们做详细说明。关于枚举类型有一个单独的设计模式：即单例设计模式。单例类是一个类只有一个实例，那么多

    系统管理员系统管理员/ 0 赞/ 217 阅读

    相关 枚举enum

    枚举类型enum C++中，枚举类型（enumeration） 是一个被命名的整型常量的集合。和类一样，每个枚举类型定义了一种新的类型。枚举属于字面值常量类型。C++包含

    以你之姓@以你之姓@/ 0 赞/ 474 阅读

    相关 枚举类（enum）

    【1】什么是枚举类？     实例（也叫对象）有限且固定不变的类，在Java里被称为枚举类。     例如，季节类，它只有4个实例（春、夏、秋、冬），并且这4个实例不

    朱雀朱雀/ 0 赞/ 524 阅读

    相关 Enum枚举类的学习

    //构造器是不允许其他类型的修饰,只能private,所以枚举类无法在类外进行初始化,保证了它不会多出几个另外的实例 //所以枚举的实例本身也就是一个初始化好的

    小咪咪小咪咪/ 0 赞/ 532 阅读

    相关 枚举类Enum

    普通类的实例可以为无数个，枚举类的对象是有限个。所有可以用作单例模式 java 枚举类型enum 的使用        最近跟同事讨论问题的时候，突然同事提到我们为

    朱雀朱雀/ 0 赞/ 594 阅读