2021年10月11日，最近有点忙...说好要好好学习😥 每天10点学习两小时的我又：咕咕了🕊...

本人学习主要来源于尚硅谷 个人源码地址

• 借鉴文章

Java 枚举

枚举 enum

什么是枚举类：

Java 枚举是一个特殊的类，一般表示一组常量

• 比如： 一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等...

• 类似这种当一个变量有几种固定可能的取值时, 可以将它定义为枚举类型

出现：

• Java1.5 之前是没有 枚举 和 注解 的.
• 那时候一般用接口常量来替代 而使用 Java 枚举类型 enum 可以更贴近地表示这种常量. 还可以配合 Switch使用...

枚举类的实现：

• JDK1.5 之前需要自定义枚举类.

• JDK 1.5 新增的 enum 关键字用于定义枚举类.

• 若枚举只有一个对象, 则可以作为一种单例模式的实现方式.

1.5之前 自定义实现枚举类：

• 私有化类的构造器，保证不能在类的外部创建其对象
• 在类的内部创建枚举类的实例，声明为： public static final 确保对象不会更改~
• 对象如果有实例变量，应该声明为： private final 通过构造器初始化

SeasonTest1.Java

**`Season.Java`**

package com.wsm;
/**
 * 自定义枚举类学习 Season季节: 一年有四个季节是固定是刚好用来做枚举类
 */
public class SeasonTest1 {
    public static void main(String[] args) {
        //春天
        Season chu = Season.SPRING;
        System.out.println(chu.toString());
        /**
         * ok,这就是自定义枚举类, 类的对象是有固定个数的！且不可更改, 救像一种规则固定的对象...
         *      常用于规则状态的定义: 商品: 缺货 代发货 待付款...等固定的状态;
         * */
    }
}

class Season{
    //1.私有化类的构造器,并给对象属性赋值: 如果有对象属性的话顺便给属性赋值~
    private Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //2.声明Season对象的属性:private final修饰,因为枚举对象是固定的不能更改的.
    private final String seasonName;
    private final String seasonDesc;

    //3.创建当前类的 固定数量的对象(一年四季):  public static final的
        //因为是私有的构造函数,类中进行创建... 如果枚举类只有一个对象,则就是一种单例模式! `饿汉式`
    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("冬天","冰天雪地");

    //ok,到这儿,自定义的枚举类就创建好了
    //如果还有其它需求可以进行扩展... 创建方法:

    /** 获取枚举类对象的属性 */
    /** 常量只有get(); 方法 */
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }

    /** toString()方法 */
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

• JDK5 之前, 的枚举类需要通过改方法进行自定义~

Java中被 Final修饰的变量的几种赋值方式

• Final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值
• 被 Final 修饰的实例变量必须显式指定初始值
• Final 修饰符通常和 static 修饰符一起使用来创建类常量

非静态Final赋值有三种：定义初始化、非静态代码块、构造方法

/*定义初始化时进行赋值
    在声明对象时直接赋值，赋值后就不可变了，这种是最容易想到的
*/
public class FinalTest {
    private final Integer num = 10;
}

/*代码块中赋值
    这种是在定义之初不进行赋值操作，而是在代码块中进行赋值，也是可以的
    构造块会在创建对象时被调用,每次创建时都会被调用,优先于类构造函数执行.
*/
public class FinalTest {
    private final Integer num;

    {
        num = 10;
    }
}

/*
构造器中赋值
    在创建对象时进行赋值,一旦对象创建完成,就不可变了,所以在创建完对象后set()方法是不能进行赋值的
*/
public class FinalTest {
    private final Integer num;
    
    public FinalTest(Integer num) {
        this.num = num;
    }
}

静态使用Final： static final

• static final赋值有两种： 定义初始化、静态代码块

/* 定义初始化 */
public class FinalTest {
    private static final Integer num = 10 ;
}

/* 静态代码块
    用static{}包裹起来的代码片段，只会执行一次 静态代码块优先于构造块执行.
*/
public class FinalTest {
    private static final Integer num;
    static {
        num = 10;
    }
}

enum 关键字实现枚举类：

• enum 定义的枚举类默认继承了 Java.lang.Enum类： 因此不能再 extends 继承其他类 但可以 implements
• 枚举类的构造器只能使用 private 权限修饰符
• 必须在枚举类的第一行声明枚举类对象

JDK 1.5 中可以在 switch 表达式中使用Enum定义的枚举类的对象 作为表达式

case 子句可以直接使用枚举值的名字(无需添加枚举类作为限定)

SeasonTest2.Java

**`Season.Java`**

package com.wsm.two;

import javax.sound.midi.Soundbank;

/***
 * JDK1.5 新增enum
 */
public class SeasonTest2 {
    public static void main(String[] args) {
        /** 秋天 */
        Season AUTUMN = Season.AUTUMN;
        System.out.println(AUTUMN);         //尝试注释 toString()方法输出: AUTUMN (对象名)
        //enum extends Java.lang.enum类

        /** enum常用方法 */
        //values()方法：
        //  返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值
        //valueOf(String str)
        //  可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
        //toString()            返回当前枚举类对象常量的名称
        /** values() */
        System.out.println("enum常用方法values()");
        Season[] values = Season.values();              //返回该enum 的所有对象
        //遍历结果集
        for (Season value : values) {
            System.out.println(value);
        }

        /** valueOf(String str) */
        System.out.println("enum常用方法valueOf(String str)");
        Season winter = Season.valueOf("WINTER");       //根据固定对象名,返回对应的enum
        System.out.println(winter);

        /** switch用法
         *      判断对象属于那一个...
         * */
        System.out.println("enum switch用法");
        switch (winter){
            case SPRING:
                System.out.println("春");
             break;
            case SUMMER:
                System.out.println("夏");
                break;
            case AUTUMN:
                System.out.println("秋");
                break;
            case WINTER:
                System.out.println("冬");
                break;
            default:
                System.out.println("没有匹配！");
        }
        
    }
}

/** 可以于自定义枚举进行比较查看~ */
enum Season{
    //1.必须在枚举类的第一行声明枚举类对象
    //枚举类的所有实例必须在枚举类中显式列出(, 分隔 ; 结尾)
    //因为枚举,本机不可修改由类访问可以取消: public static final 类
//    public static final Season SPRING = new Season("春天","春暖花开");
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");

    //2.声明Season对象的属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;

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

    //扩展方法
    /** get */
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    /** toString
     *      注释方法直接输出发现,即使不重新toString(); 也不是打印对象的: 地址值(栈指向堆的地址！)
     *      因为: enum类,是继承于 Java.lang.enum的,而不是 Object类
     * */
//    @Override
//    public String toString() {
//        return "Season{" +
//                "seasonName='" + seasonName + '\'' +
//                ", seasonDesc='" + seasonDesc + '\'' +
//                '}';
//    }
}

enum 常用方法

enum 高级：implements实现类

• enum 类继承了 java.lang.enum类 Java单根性所以不能在继承, 但Java 可以 多实现

• eunm 类 还可以 实现接口...达到扩展的方式

实现方式：

• 正常实现，重写方法.... 但这样所有的对象, 方法实现都一样！

  SeasonTest3

  Season

  Info

  public class SeasonTest3 {
      public static void main(String[] args) {
          Season autumn = Season.AUTUMN;
          autumn.show();
      }
  }
  
  //使用enum关键字枚举类 implements 实现接口,重写show()方法~
  enum Season implements Info{
      SPRING("春天","春暖花开"),
      SUMMER("夏天","夏日炎炎"),
      AUTUMN("秋天","秋高气爽"),
      WINTER("冬天","冰天雪地");
  
      //2.声明Season对象的属性:private final修饰
      private final String seasonName;
      private final String seasonDesc;
  
      //3.私有化类的构造器,并给对象属性赋值
  
      private Season(String seasonName,String seasonDesc){
          this.seasonName = seasonName;
          this.seasonDesc = seasonDesc;
      }
    //重写接口的方法！
      @Override
      public void show() {
          System.out.println("这是一个季节~");
      }
  }
  
  /** 接口 */
  interface Info{
      void show();
  }
  

• 给每个enum 对象，来一个特有的固定实现！

  public class SeasonTest4 {
      public static void main(String[] args) {
          Season autumn = Season.AUTUMN;
          autumn.show();
      }
  }
  
  //使用enum关键字枚举类 implements 实现接口,重写show()方法~
  enum Season implements Info {
      SPRING("春天","春暖花开"){
          @Override
          public void show() { System.out.println("春天在哪里？");  }
      },
      SUMMER("夏天","夏日炎炎"){
          @Override
          public void show() { System.out.println("宁夏");           }
      },
      AUTUMN("秋天","秋高气爽"){
          @Override
          public void show() { System.out.println("秋天不回来");    }
      },
      WINTER("冬天","冰天雪地"){
          @Override
          public void show() { System.out.println("大约在冬季");  }
      };
  
      //2.声明Season对象的属性:private final修饰
      private final String seasonName;
      private final String seasonDesc;
  
      //3.私有化类的构造器,并给对象属性赋值
      private Season(String seasonName,String seasonDesc){
          this.seasonName = seasonName;
          this.seasonDesc = seasonDesc;
      }
  }
  
  /** 接口 */
  interface Info{
      void show();
  }
  

枚举集合

在 Java 语言中和枚举类相关的，还有两个枚举集合类 java.util.EnumSet 和 java.util.EnumMap

使用 EnumSet 可以保证元素不重复，并且能获取指定范围内的元素

public class EnumTest {
    public static void main(String[] args) {
        List<ErrorCodeEnum> list = new ArrayList<ErrorCodeEnum>();
        list.add(ErrorCodeEnum.SUCCESS);
        list.add(ErrorCodeEnum.SUCCESS);    //重复元素
        list.add(ErrorCodeEnum.SYS_ERROR);
        list.add(ErrorCodeEnum.NAMESPACE_NOT_FOUND);
        // 去掉重复数据
        EnumSet<ErrorCodeEnum> enumSet = EnumSet.copyOf(list);
        System.out.println("去重：" + enumSet);

        // 获取指定范围的枚举（获取所有的失败状态）
        EnumSet<ErrorCodeEnum> errorCodeEnums = EnumSet.range(ErrorCodeEnum.ERROR, ErrorCodeEnum.UNKNOWN_ERROR);
        System.out.println("所有失败状态：" + errorCodeEnums);
    }
}

enum ErrorCodeEnum {
    SUCCESS(1000, "success"),
    ERROR(2001, "parameter error"),
    SYS_ERROR(2002, "system error"),
    NAMESPACE_NOT_FOUND(2003, "namespace not found"),
    NODE_NOT_EXIST(3002, "node not exist"),
    NODE_ALREADY_EXIST(3003, "node already exist"),
    UNKNOWN_ERROR(9999, "unknown error");

    private int code;
    private String msg;

    ErrorCodeEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public int code() {   return code;  }

    public String msg() { return msg;   }
}

• EnumMap 与 HashMap 类似，不过它是一个专门为枚举设计的 Map 集合

• 相比 HashMap 来说它的性能更高，因为它内部放弃使用链表和红黑树的结构，采用数组作为数据存储的结构

  • 以枚举作为 key，查询直接找到对应的 数组下标 快速定位元素

    EnumMap<枚举对象,Object>
    

为什么使用枚举？😕

更强的 类型约束

• 在枚举没有诞生之前，也就是 JDK 1.5 版本之前

• 我们通常会使用 int 常量来表示枚举，用来区分，状态类型： B站上传视频为例，视频一般有三个状态：草稿、审核和发布

  int类型本身并不具备安全性，假如某个程序员在定义int时少些了一个final关键字，

  那么就会存在被其他人修改的风险，反观枚举类，它“天然”就是一个常量类，不存在被修改的风险。

  使用 int 类型的语义不够明确 枚举更加清晰表示一种状态

单例模式：

• 使用枚举实现 单例模式更加简单！

线程安全：

• 枚举类最终会被编译为被 final 修饰的普通类
• 它的所有属性也都会被 static 和 final 关键字修饰，所以枚举类在项目启动时就会被 JVM 加载并初始化 且不允许更改！线程安全

方便比较：

• 枚举比较时使用 == 就够了，因为枚举类是在程序加载时就创建了（它并不是 new 出来的） 每个对象全局只有一个！
• == 比较地址，相同对象的地址也相同！

ok, 枚举就介绍到这儿了，晚安，集美门😘