Java 枚举

 

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 常用方法

方法名称描述
values() 以数组形式返回枚举类型的所有成员
valueOf( String ) 将普通字符串转换为枚举实例
compareTo() 比较两个枚举成员在定义时的顺序
ordinal() 获取枚举成员的索引位置

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, 枚举就介绍到这儿了，晚安，集美门😘

 

posted on 2021-11-11 10:35  Java慈祥s  阅读(1077)  评论(0)  编辑  收藏  举报

导航