一：引出枚举

要求创建季节（Serson）对象

  1. public class Test00 {
  2.     public static void main(String[] args) {
  3.         Season spring = new Season("春天", "温暖");
  4.         Season summer = new Season("夏天", "炎热");
  5.         Season autumn = new Season("秋天", "凉爽");
  6.         Season winter = new Season("冬天", "寒冷");
  8.         //因为对于季节而已，他的对象(具体值)，是固定的四个，不会有更多
  9.         //这样设计，不能体现季节是固定的四个对象
  10.         //因此，这样的设计不好===>
  11.         //枚举类[枚: 一个一个 举： 例举 , 即把具体的对象一个一个例举出来的类
  12.     }
  13. }
  15. class Season {
  16.     private String name;
  17.     private String desc;
  19.     public Season(String name, String desc) {
  20.         this.name = name;
  21.         this.desc = desc;
  22.     }
  23.     public String getName() {
  24.         return name;
  25.     }
  26.     public void setName(String name) {
  27.         this.name = name;
  28.     }
  30.     public String getDesc() {
  31.         return desc;
  32.     }
  33.     public void setDesc(String desc) {
  34.         this.desc = desc;
  35.     }
  36. }

二：基本介绍

1：创建Season对象有如下特点

  • 季节的值是有限的几个值
  • 只读，不需要修改

    2：解决方案——枚举

  1. 枚举对应英文（enumeration，简写enum）
  2. 枚举是一组常量的集合
  3. 可以这样理解：枚举属于一种特殊的类，里面包含一组有限的特定的对象

    3：枚举的两种实现方式

  • 自定义实现枚举
  • 使用enum关键字实现枚举

    二：自定义类枚举

  1. 不需要提供setXxx方法，因为枚举对象值通常为只读.
  2. 对枚举对象/属性使用final + static共同修饰，实现底层优化.
  3. 枚举对象名通常使用全部大写常量的命名规范.
  4. 枚举对象根据需要，也可以有多个属性 ```java public class Test00 { public static void main(String[] args) {
    1.  System.out.println(Season.AUTUMU);
    2.  System.out.println(Season.WINTER);
    } }

class Season { private String name; private String desc;

  1. public static final Season SPRING = new Season("春天", "温暖");
  2. public static final Season SUMMER = new Season("夏天", "炎热");
  3. public static final Season AUTUMU = new Season("秋天", "凉爽");
  4. public static final Season WINTER = new Season("冬天", "寒冷");
  6. //1：将构造器私有化，防止直接new
  7. //2: 去掉set方法，因为不需要修改
  8. //3: 在Season内部，直接创建固定对象
  9. //4: 优化可以加入final修饰符
  10. private Season(String name, String desc) {
  11.     this.name = name;
  12.     this.desc = desc;
  13. }
  15. public String getName() {
  16.     return name;
  17. }
  19. public String getDesc() {
  20.     return desc;
  21. }
  23. @Override
  24. public String toString() {
  25.     return "Season{" +
  26.             "name='" + name + '\'' +
  27.             ", desc='" + desc + '\'' +
  28.             '}';
  29. }

}

  1. <a name="te5jv"></a>
  2. ### 三：使用enum关键字实现枚举
  3. ```java
  4. package Date0818.Test00;
  6. /**
  7.  * 作者：sakura
  8.  * 日期：2022年08月19日 11:18
  9.  */
  10. public class Test {
  11.     public static void main(String[] args) {
  12.         System.out.println(Season.SPRING);
  13.         System.out.println(Season.AUTUMN);
  14.     }
  15. }
  17. enum Season {
  18.     SPRING("春天", "温暖"),
  19.     WINTER("冬天", "寒冷"),
  20.     AUTUMN("秋天", "凉爽"),
  21.     SUMMER("夏天", "炎热");
  23.     private String name;
  24.     private String desc;
  26.     private Season(String name, String desc) {
  27.         this.name = name;
  28.         this.desc = desc;
  29.     }
  31.     public String getName() {
  32.         return name;
  33.     }
  35.     public String getDesc() {
  36.         return desc;
  37.     }
  39.     @Override
  40.     public String toString() {
  41.         return "Season{" +
  42.                 "name='" + name + '\'' +
  43.                 ", desc='" + desc + '\'' +
  44.                 '}';
  45.     }
  46. }

四：enum关键字实现枚举注意事项

  • 当我们使用enum 关键字开发一个枚举类时，默认会继承Enum类, 而且是一个final 类[如何证明],老师使用javap 工 具来演示
  • 传统的 public static final Season2 SPRING = new Season2(“春天”, “温暖”); 简化成 SPRING(“春天”, “温暖”)， 这里必 须知道，它调用的是哪个构造器.
  • 如果使用无参构造器 创建 枚举对象，则实参列表和小括号都可以省略
  • 当有多个枚举对象时，使用,间隔，最后有一个分号结尾

  • 枚举对象必须放在枚举类的行首.

    五：enum关键字实现枚举-课堂练习

    六：enum关键字常用方法说明

    image.png ```java public class Test01 { public static void main(String[] args) {

    1.   Season Spring =  Season.SPRING;
    2.   Season Autumu = Season.AUTUMN;
    4.   //1: toString()方法：Enum已经重写过了, 返回的是当前对象名
    5.   System.out.println(Spring);
    6.   System.out.println(Spring.toString());
    8.   //2:返回当前对象名（常量名），子类中不能重写
    9.   System.out.println(Spring.name());
    11.   //3：ordinal()返回当前对象的位置号，默认从 0 开始。按照在Enum中定义的顺序
    12.   System.out.println(Spring.ordinal());
    14.   //4: value 返回当前枚举类中所有的常量
    15.   //从反编译可以看出 values 方法，返回 Season2[]
    16.   //Season.values() / 枚举类.values就是个数组，里面包含所有枚举类成员
    17.   Season[] seasons = Season.values();
    19.   //增强for循环
    20.   //执行流程依次从Season.values()中取出数据赋给season
    21.   for (Season season:Season.values()){
    22.       System.out.println(season);
    23.   }
    24.   //5：比较两个编号，相减，此处0-2 = -2
    25.   System.out.println(Spring.compareTo(Autumu));
    27.   //6:将字符串转换成枚举对象，要求字符串必须 为已有的常量名，否则报异常
    28.   Season valueOf = Season.valueOf("SPRING");
    29.   System.out.println(valueOf);

    } }

  1. :::info
  2. **_重点：增强for循环_**<br />int[] str = {1,2,4,4,5,7,8};<br />for (int i = 0; i < str.length; i++) {<br />    System.out.println(str[i]);<br />}
  4. System.out.println("------------------");<br />//从str中取出数据赋给i,如果取出完毕，则退出 for<br />for (int i : str ){<br />    System.out.println(i);<br />}
  5. :::
  6. <a name="a1rrw"></a>
  7. ### 七：enum实现接口
  9. 1. **使用 enum关键字后，就不能再继承其它类了，因为 enum会隐式继承 Enum，而 Java 是单继承机制。**
  10. 2. **枚举类和普通类一样，可以实现接口，**
  11. ```java
  12. public class Test {
  13.     public static void main(String[] args) {
  14.         System.out.println(Season.AUTUMN.toString());
  15.     }
  16. }
  17. interface A{
  18.     public void Play();
  19. }
  20. enum Season  implements A {
  21.     SPRING("春天", "温暖"),
  22.     WINTER("冬天", "寒冷"),
  23.     AUTUMN("秋天", "凉爽"),
  24.     SUMMER("夏天", "炎热");
  26.     private String name;
  27.     private String desc;
  29.     private Season(String name, String desc) {
  30.         this.name = name;
  31.         this.desc = desc;
  32.     }
  33.     @Override
  34.     public void Play() {
  36.     }
  37. }