• 枚举类就是一个普通的类，私有化构造器，不允许该类在外部被创建，实则是一种单列模式的实现方式
  • 在枚举类内部进行对该类的创建，然后将创建的对象暴露出去。而且对象是不可更改的所有需要使用 public static final修饰
  • 每次使用时，使用类名.属性名，实则是每一次都拿到的是一个当前类的对象。

1、自定义枚举类

枚举类的属性

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

2、创建自定义枚举类

  • 声明枚举对象的属性：private final 修饰
  • 私有化类的构造器，并给对象的属性赋值
  • 提供当前枚举类的对个对象

  • 其他诉求 ```java /**

    • 一、枚举类的使用
    • 1.枚举类的理解：
      1.  类的对象只有有限个，确定的。我们称此类为枚举类。
    • 2.当需要定义一组常量时，强烈建议使用枚举类
    • 3.若枚举只有一个对象, 则可以作为一种单例模式的实现方式。 *
    • 二、如何定义枚举类
    • 方式一：JDK1.5之前需要自定义枚举类

    • 方式二：JDK 1.5 新增的enum 关键字用于定义枚举类 / public class SeasonTest { public static void main(String[] args) { Season spring = Season.SPRING; System.out.println(spring); } } //自定义枚举类 class Season{ //1.声明Season对象的属性:private final修饰 private final String seasonName; private final String seasonDesc;

      //2.私有化类的构造器,并给对象属性赋值 private Season(String seasonName,String seasonDesc){ this.seasonName = seasonName; this.seasonDesc = seasonDesc; }

      //3.提供当前枚举类的多个对象 public static final Season SPRING = new Season(“春天”,”万物复苏”); public static final Season SUMMER = new Season(“夏天”,”烈日炎炎”); public static final Season AUTUMN = new Season(“秋天”,”金秋送爽”); public static final Season WINTER = new Season(“冬天”,”白雪皑皑”);

      //4.其他诉求：获取枚举类对象的属性 public String getSeasonName() { return seasonName; }

      public String getSeasonDesc() { return seasonDesc; }

      //4.其他诉求1：提供toString() @Override public String toString() { return “Season{“ +

      1.     "seasonName='" + seasonName + '\'' +
      2.     ", seasonDesc='" + seasonDesc + '\'' +
      3.     '}';

      } }

  1. <a name="kTUie"></a>
  2. # 3、使用enum关键字定义枚举类
  3. 使用说明
  5. - **使用enum定义的枚举类默认继承了java.lang.Enum类，因此不能再继承其他类，类名.对象名输出的就是该对象名，相当于是一个常量**
  6. - **枚举类的构造器只能使用private 权限修饰符**
  7. - 枚举类的所有实例必须在枚举类中显式列出(, 分隔; 结尾)。列出的实例系统会自动添加public static final 修饰
  8. - 必须在枚举类的第一行声明枚举类对象
  10. JDK 1.5 中可以在switch 表达式中使用Enum定义的枚举类的对象作为表达式, case 子句可以直接使用枚举值的名字, 无需添加枚举类作为限定。
  11. ```java
  12. /**
  13.  * 使用enum关键字定义枚举类
  14.  * 说明：定义的枚举类默认继承于java.lang.Enum类
  15.  */
  16. public class SeasonTest1 {
  17.     public static void main(String[] args) {
  18.         Season1 summer = Season1.SUMMER;
  19.         //toString():
  20.         System.out.println(summer.toString());
  22.         System.out.println(Season1.class.getSuperclass());
  23.     }
  24. }
  26. //使用enum关键字枚举类
  27. enum Season1{
  28.     //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
  29.     SPRING("春天","万物复苏"),
  30.     SUMMER("夏天","烈日炎炎"),
  31.     AUTUMN("秋天","金秋送爽"),
  32.     WINTER("冬天","白雪皑皑");
  34.     //2.声明Season对象的属性:private final修饰
  35.     private final String seasonName;
  36.     private final String seasonDesc;
  38.     //3.私有化类的构造器,并给对象属性赋值
  39.     private Season1(String seasonName,String seasonDesc){
  40.         this.seasonName = seasonName;
  41.         this.seasonDesc = seasonDesc;
  42.     }
  44.     //4.其他诉求：获取枚举类对象的属性
  45.     public String getSeasonName() {
  46.         return seasonName;
  47.     }
  49.     public String getSeasonDesc() {
  50.         return seasonDesc;
  51.     }
  52. }
  53. s

4、Enum类中的常用方法

image.png

4.1、Enum类的主要方法：

  • values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
  • valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
  • toString()：返回当前枚举类对象常量的名称 ```java /**
    • 使用enum关键字定义枚举类
    • 说明：定义的枚举类默认继承于java.lang.Enum类 *
    • 三、Enum类的常用方法
    • values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
    • valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
    • toString()：返回当前枚举类对象常量的名称 */ public class SeasonTest1 { public static void main(String[] args) { Season1 summer = Season1.SUMMER; //toString(): System.out.println(summer.toString());

// System.out.println(Season1.class.getSuperclass()); System.out.println(“**“); //values():返回所有的枚举类对象构成的数组 Season1[] values = Season1.values(); for(int i = 0;i < values.length;i++){ System.out.println(values[i]); } System.out.println(“**“); Thread.State[] values1 = Thread.State.values(); for(int i = 0;i < values1.length;i++){ System.out.println(values1[i]); }

  1.     //valueOf(String objName):返回枚举类中对象名是objName的对象。
  2.     Season1 winter = Season1.valueOf("WINTER");
  3.     //如果没有objName的枚举类对象，则抛异常：IllegalArgumentException

// Season1 winter = Season1.valueOf(“WINTER1”); System.out.println(winter);

  1. }

}

//使用enum关键字枚举类 enum Season1{ //1.提供当前枚举类的对象，多个对象之间用”,”隔开，末尾对象”;”结束 SPRING(“春天”,”万物复苏”), SUMMER(“夏天”,”烈日炎炎”), AUTUMN(“秋天”,”金秋送爽”), WINTER(“冬天”,”白雪皑皑”);

  1. //2.声明Season对象的属性:private final修饰
  2. private final String seasonName;
  3. private final String seasonDesc;
  5. //3.私有化类的构造器,并给对象属性赋值
  6. private Season1(String seasonName,String seasonDesc){
  7.     this.seasonName = seasonName;
  8.     this.seasonDesc = seasonDesc;
  9. }
  11. //4.其他诉求：获取枚举类对象的属性
  12. public String getSeasonName() {
  13.     return seasonName;
  14. }
  16. public String getSeasonDesc() {
  17.     return seasonDesc;
  18. }
  20. //4.其他诉求1：提供toString()

// @Override // public String toString() { // return “Season{“ + // “seasonName=’” + seasonName + ‘\’’ + // “, seasonDesc=’” + seasonDesc + ‘\’’ + // ‘}’; // } }

  1. <a name="R3Y79"></a>
  2. # 5、使用enum关键字定义的枚举类实现接口
  3. ```java
  4. /**
  5.  * 使用enum关键字定义枚举类
  6.  * 说明：定义的枚举类默认继承于java.lang.Enum类
  7.  *
  8.  * 四、使用enum关键字定义的枚举类实现接口的情况
  9.  *   情况一：实现接口，在enum类中实现抽象方法
  10.  *   情况二：让枚举类的对象分别实现接口中的抽象方法
  11.  */
  12. public class SeasonTest1 {
  13.     public static void main(String[] args) {
  14.         //values():返回所有的枚举类对象构成的数组
  15.         Season1[] values = Season1.values();
  16.         for(int i = 0;i < values.length;i++){
  17.             System.out.println(values[i]);
  18.             values[i].show();
  19.         }
  21.         //valueOf(String objName):返回枚举类中对象名是objName的对象。
  22.         Season1 winter = Season1.valueOf("WINTER");
  23.         winter.show();
  24.     }
  25. }
  27. interface Info{
  28.     void show();
  29. }
  31. //使用enum关键字枚举类
  32. enum Season1 implements Info{
  33.     //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
  34.     SPRING("春天","春暖花开"){
  35.         @Override
  36.         public void show() {
  37.             System.out.println("一元复始、万物复苏");
  38.         }
  39.     },
  40.     SUMMER("夏天","夏日炎炎"){
  41.         @Override
  42.         public void show() {
  43.             System.out.println("蝉声阵阵、烈日当空");
  44.         }
  45.     },
  46.     AUTUMN("秋天","秋高气爽"){
  47.         @Override
  48.         public void show() {
  49.             System.out.println("天高气清、金桂飘香");
  50.         }
  51.     },
  52.     WINTER("冬天","冰天雪地"){
  53.         @Override
  54.         public void show() {
  55.             System.out.println("寒冬腊月、滴水成冰");
  56.         }
  57.     };
  59.     //2.声明Season对象的属性:private final修饰
  60.     private final String seasonName;
  61.     private final String seasonDesc;
  63.     //3.私有化类的构造器,并给对象属性赋值
  64.     private Season1(String seasonName,String seasonDesc){
  65.         this.seasonName = seasonName;
  66.         this.seasonDesc = seasonDesc;
  67.     }
  69.     //4.其他诉求：获取枚举类对象的属性
  70.     public String getSeasonName() {
  71.         return seasonName;
  72.     }
  74.     public String getSeasonDesc() {
  75.         return seasonDesc;
  76.     }
  78.     //4.其他诉求1：提供toString()
  79. //    @Override
  80. //    public String toString() {
  81. //        return "Season{" +
  82. //                "seasonName='" + seasonName + '\'' +
  83. //                ", seasonDesc='" + seasonDesc + '\'' +
  84. //                '}';
  85. //    }
  87. //    @Override
  88. //    public void show() {
  89. //        System.out.println("这是一个季节。");
  90. //    }
  91. }