枚举类

枚举类的定义

类的对象只有有限个，确定的。

当需要定义一组常量时，强烈建议使用枚举类

枚举类的实现

  • 方式一：jdk5.0之前，自定义枚举类
  • 方式二：jdk5.0，可以使用enum关键字定义枚举类

枚举类的属性

  • 枚举类对象的属性不应允许被改动, 所以应该使用 private final 修饰
  • 枚举类的使用 private final 修饰的属性应该在构造器中为其赋值
  • 若枚举类显式的定义了带参数的构造器, 则在列出枚举值时也必须对应的传入参数

方式一：自定义枚举类

  • 私有化类的构造器，保证不能在类的外部创建其对象
  • 在类的内部创建枚举类的实例。声明为：public static final
  • 对象如果有实例变量，应该声明为private final，并在构造器中初始化
  1. public class EnumTest {
  2.     public static void main(String[] args) {
  3.         Season spring=Season.SPRING;
  4.         System.out.println(spring);
  5.     }
  6. }
  8. //自定义枚举类
  9. class Season{
  10.     //1、声明Season对象的属性
  11.     private final String SeasonName;
  12.     private final String SeasonDesc;
  13.     //2、私有化类的构造器
  14.     private Season(String SeasonName,String SeasonDesc){
  15.         this.SeasonName=SeasonName;
  16.         this.SeasonDesc=SeasonDesc;
  17.     }
  18.     //3、提供当前枚举类的多个对象：public static final
  19.     public static final Season SPRING = new Season("春天","春暖花开");
  20.     public static final Season SUMMER = new Season("夏天","夏日炎炎");
  21.     public static final Season AUTUMN = new Season("秋天","秋高气爽");
  22.     public static final Season WINTER = new Season("冬天","冰天雪地");
  24.     //其他诉求：获取枚举类对象的属性
  26.     public String getSeasonName() {
  27.         return SeasonName;
  28.     }
  30.     public String getSeasonDesc() {
  31.         return SeasonDesc;
  32.     }
  33.     //4、提供toString()
  35.     @Override
  36.     public String toString() {
  37.         return "Season{" +
  38.                 "SeasonName='" + SeasonName + '\'' +
  39.                 ", SeasonDesc='" + SeasonDesc + '\'' +
  40.                 '}';
  41.     }
  42. }

方式二：使用enum定义枚举类

  • 使用 enum 定义的枚举类默认继承了 java.lang.Enum类，因此不能再继承其他类
  • 枚举类的构造器只能使用 private 权限修饰符
  • 枚举类的所有实例必须在枚举类中显式列出(, 分隔 ; 结尾)。列出的实例系统会自动添加 public static final 修饰
  • 必须在枚举类的第一行声明枚举类对象
  1. public enum SeasonEnum {
  2.     SPRING("春天","春风又绿江南岸"),
  3.     SUMMER("夏天","映日荷花别样红"),
  4.     AUTUMN("秋天","秋水共长天一色"),
  5.     WINTER("冬天","窗含西岭千秋雪");
  7.     private final String seasonName;
  8.     private final String seasonDesc;
  9.     private SeasonEnum(String seasonName, String seasonDesc) {
  10.         this.seasonName = seasonName;
  11.         this.seasonDesc = seasonDesc;
  12.     }
  13.     public String getSeasonName() {
  14.         return seasonName;
  15.     }
  16.     public String getSeasonDesc() {
  17.         return seasonDesc;
  18.     }
  19. }

Enum类的主要方法：

  • values() 方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
  • valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
  • toString()：返回当前枚举类对象常量的名称

实现接口的枚举类

  • 和普通 Java 类一样，枚举类可以实现一个或多个接口
  • 若每个枚举值在调用实现的接口方法呈现相同的行为方式，则只要统一实现该方法即可。
  • 若需要每个枚举值在调用实现的接口方法呈现出不同的行为方式,则可以让每个枚举值分别来实现该方法
  1. public class EnumTest2 {
  2.     public static void main(String[] args) {
  3.         Season2 summer=Season2.SUMMER;
  4.         //toString()
  5.         System.out.println(summer.toString());
  7.         //value()
  8.         Season2[]values=Season2.values();
  9.         for (int i=0;i<values.length;i++){
  10.             System.out.println(values[i]);
  11.             values[i].show();
  12.         }
  15.         //线程的状态
  16.         Thread.State[]values1=Thread.State.values();
  17.         for (Thread.State state:values1
  18.              ) {
  19.             System.out.println(state);
  20.         }
  22.         //valueOf(String objName):返回枚举类中对象名是objName的对象
  23.         Season2 winter = Season2.valueOf("WINTER");
  24.         System.out.println(winter);
  25.         //System.out.println(Season2.class.getSuperclass());
  26.     }
  27. }
  29. interface Info{
  30.     void show();
  31. }
  33. //enum枚举类
  34. enum Season2 implements Info{
  35.     //1、提供当前枚举类的对,多个对象之间用,隔开，末尾用；结束
  36.      SPRING ("春天","春暖花开"){
  37.         @Override
  38.         public void show() {
  39.             System.out.println("春天在哪里");
  40.         }
  41.     },
  42.      SUMMER ("夏天","夏日炎炎"){
  43.          @Override
  44.          public void show() {
  45.              System.out.println("宁静的夏天");
  46.          }
  47.      },
  48.      AUTUMN ("秋天","秋高气爽"){
  49.          @Override
  50.          public void show() {
  51.              System.out.println("秋天不回来");
  52.          }
  53.      },
  54.      WINTER ("冬天","冰天雪地"){
  55.          @Override
  56.          public void show() {
  57.              System.out.println("大约在冬季");
  58.          }
  59.      };
  60.     //2、声明Season对象的属性
  61.     private final String SeasonName2;
  62.     private final String SeasonDesc2;
  63.     //3、私有化类的构造器
  64.     private Season2(String SeasonName2,String SeasonDesc2){
  65.         this.SeasonName2=SeasonName2;
  66.         this.SeasonDesc2=SeasonDesc2;
  67.     }
  69.     //4、其他诉求：获取枚举类对象的属性
  70.     public String getSeasonName2() {
  71.         return SeasonName2;
  72.     }
  74.     public String getSeasonDesc2() {
  75.         return SeasonDesc2;
  76.     }
  78.     @Override
  79.     public void show() {
  80.         System.out.println("这是一个季节");
  81.     }
  83. }