Java枚举的使用心得

最新推荐文章于 2022-10-25 22:54:04 发布
最新推荐文章于 2022-10-25 22:54:04 发布
阅读量178 收藏 1
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27181955/article/details/124434265
版权

Java枚举

枚举的理解

枚举，的好处就是，在代码输入的时候，可以明确知道可以输入哪些值。而常量，则无法限制。

优点1. 强制性约束

  • 可以让调用者直观且明确的知道，可以传递哪些值
  • 可以约束调用者，必须用指定的Enum。 （看例子）

例子：

public class ConstantTest {
    // 使用常量的好处是简单。这个不用证明大家都明白
    static class OrderConstant {
        // 订单创建
        private static final String ORDER_BUILDER = "01";

        // 订单提交
        private static final String ORDER_COMMIT = "05";

        // 订单取消
        private static final String ORDER_CANCEL = "98";
    }

    enum OrderEnum {
        ORDER_BUILDER,ORDER_COMMIT,ORDER_CANCEL
    }
    @Data
    static class Order {
        private String orderNo;
        private String status;
        private OrderEnum orderEnumStatus;
        private Date createDate;
    }

    public static void main(String[] args) {
        test1();
        test2();

    }

    // 优点1. 强制约束
    public static void test1() {
        Order order = new Order();

//        如果是常量，正常人是这么用的。
        order.setStatus(OrderConstant.ORDER_BUILDER);

        // 准备跑路的程序员可以这么用：可以不通过OrderConstant 进行填写。。有些人可能会瞎几把写代码
        // 这样代码没有约束
        order.setStatus("提桶跑路");

        // 必须强制性天一个Enum类型。 这个就是优点。。
        order.setOrderEnumStatus(OrderEnum.ORDER_BUILDER);

    }

    // 优点2. 可以使用==号，并且不需要做null校验
    public static void test2() {
        Order order = new Order();
        order.setOrderEnumStatus(null);
        if (order.getOrderEnumStatus() == OrderEnum.ORDER_BUILDER) {
            System.out.println("订单创建");
        }
        if (order.getOrderEnumStatus() == null) {
            System.out.println("null 你也敢传");
        }
    }
}

优点2 可以直接使用==

可以直接使用并且，不需要害怕空异常

// 优点2. 可以使用==号，并且不需要做null校验
public static void test2() {
  Order order = new Order();
  order.setOrderEnumStatus(null);
  if (order.getOrderEnumStatus() == OrderEnum.ORDER_BUILDER) {
    System.out.println("订单创建");
  }
  if (order.getOrderEnumStatus() == null) {
    System.out.println("null 你也敢传");
  }
}

优点3 可以用Switch

枚举具体API

枚举格式

修饰符 enum  枚举名称 {
  实例1名称, 实例2名称...;
}

枚举的实质

  • 枚举类实际是 Enum的子类
public abstract class Enum<E extends Enum<E>> 
  extends Object implements Comparable<E>, Serializable

  • Enum 继承了Object 所以，拥有Object 所有方法。

  • Enum可以实现接口。不能继承。

    java 是单继承，所以enum不能再使用extends 。 但是可以实现其他接口。

    /**
 * @author liuqh
 * @version 1.0
 * @date 2022/4/26
 */
public enum StatusEnum implements NameCodeEnum<String> {
    COMMIT("01", "提交"),TEMP("00", "草稿"),PAUSE("03", "暂停");

    private String name;
    private String code;
    StatusEnum(String code, String name) {
        this.code = code;
        this.name = name;

    }
    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getCode() {
        return code;
    }
}

  • 枚举字面量

    例如：上面的COMMIT 字面量就是COMMIT字符串

  • 枚举特有方法

    // 获得Enum的类对象
类<E>	getDeclaringClass();
// 重写了toString 方法。返回枚举常量名称
String  toString();
// 通过枚举常量名称, 返回枚举  
static <T extends Enum<T>> T  valueOf(类<T> enumType, String name)

// 返回枚举常量名称, 跟自定义的name没有半毛钱关系
public final String name();
// 返回枚举的顺序
public final int ordinal()

  • 枚举构造器

    咱们可以定义自己的构造器，但是枚举内部都会调用Enum的构造器存入ordinal 与 枚举字面量name

    protected Enum(String name,
               int ordinal)
唯一的构造函数。 程序员无法调用此构造函数。 它由编译器响应枚举类型声明发出的代码使用。
参数
name - - 此枚举常量的名称，它是用于声明它的标识符。
ordinal - - 这个枚举常数的序数（它在枚举声明中的位置，其中初始常数被分配为零的序数）。

通过接口简化枚举

通常业务经常会定义code 与 name, 例如： COMMIT(“01”, “提交”)。 01是code , 提交是name。

经常会有通过code 查找对应的枚举，或者通过name 查找对应的枚举。

问题案例

经常实现：

package com.moveo.dev.enums;

/**
 * @author liuqh
 * @version 1.0
 * @date 2022/4/26
 */
public enum ErrorEnum {
    PASSWD_ERROR("1003", "密码错误"),
    USERNAME_ERROR("1004", "用户名错误"),
    SYSTEM_ERROR("2001", "系统错误")
    ;

    private final String code;
    private final String name;

    private ErrorEnum(String code, String name) {
        this.code = code;
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public String getName() {
        return name;
    }

    /**
     * 通过code 返回枚举的中文值
     * @author liuqh
     * @param code
     * @return String 空返回null
     * @date 2022/4/26
     **/
    public static String getNameByCode(String code) {
        ErrorEnum[] values = ErrorEnum.values();
        for (ErrorEnum errorEnum : values) {
            if (errorEnum.getCode().equals(code)) {
                return errorEnum.getName();
            }
        }
        // 未找到返回null
        return null;
    }

    /**
     * 通过code 返回枚举。 没找到返回null
     * @author liuqh
     * @param code
     * @return ErrorEnum
     * @date 2022/4/26
     **/
    public static ErrorEnum getEnumByCode(String code) {
        ErrorEnum[] values = ErrorEnum.values();
        for (ErrorEnum errorEnum : values) {
            if (errorEnum.getCode().equals(code)) {
                return errorEnum;
            }
        }
        // 未找到返回null
        return null;
    }
}

问题是每个枚举类型，都需要写一遍getEnumByCode。造成大量的复制粘贴操作

解决案例

思路：枚举虽然不能继承，但是可以通过接口。使用工具类来完成操作。

接口：

/**
 * 这里采用T泛型的原因是，有的枚举类并不需要枚举名且枚举code可能为String 或者Integer
 *
 *
 * @author liuqh
 * @date  2022/4/25
 * @version 1.0
 */
public interface CodeEnum<T> {
    /**
     *获取枚举值
     * @return
     */
    T getCode();
}


/**
 * 带有枚举值以及枚举名称的枚举接口（可以使用{@link EnumUtils} 中的方法）
 *
 * @author liuqh
 * @version 1.0
 * @date 2022/4/25
 */
public interface NameCodeEnum<T> extends CodeEnum<T> {

    /**
     * 获取枚举名称
     *
     * @author liuqh
     * @return String
     * @date 2022/4/25
     **/
    String getName();
}

实现类：

public enum StatusEnum implements NameCodeEnum<String> {
    COMMIT("01", "提交"),TEMP("00", "草稿"),PAUSE("03", "暂停");

    private final String name;
    private final String code;

    StatusEnum(String code, String name) {
        this.code = code;
        this.name = name;

    }
    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getCode() {
        return code;
    }
}

枚举工具类：

package com.moveo.dev.enums;

import org.apache.commons.lang3.StringUtils;

/**
 * @author liuqh
 * @version 1.0
 * @date 2022/4/25
 */
public class EnumUtils {

    /**
     * 判断枚举值是否存在于指定枚举数组中
     *
     * @param enums 枚举数组
     * @param code 枚举code
     * @return 是否存在
     */
    public static <T> boolean isExist(CodeEnum<T>[] enums, T code) {
        if (code == null) {
            return false;
        }
        for (CodeEnum<T> e : enums) {
            if (code.equals(e.getCode())) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断枚举值是否存与指定枚举类中
     *
     * @param enumClass 枚举类
     * @param code     枚举code
     * @param <E>       枚举类型
     * @param <V>       值类型
     * @return true：存在
     */
    @SuppressWarnings("unchecked")
    public static <E extends Enum<? extends CodeEnum<V>>, V> boolean isExist(Class<E> enumClass, V code) {
        for (Enum<? extends CodeEnum<V>> e : enumClass.getEnumConstants()) {
            if (((CodeEnum<V>) e).getCode().equals(code)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 根据枚举值获取其对应的名字
     *
     * @param enums 枚举列表
     * @param code 枚举值
     * @return 枚举名称
     */
    public static <T> String getNameByCode(NameCodeEnum<T>[] enums, T code) {
        if (code == null) {
            return null;
        }
        for (NameCodeEnum<T> e : enums) {
            if (code.equals(e.getCode())) {
                return e.getName();
            }
        }
        return null;
    }

    /**
     * 根据枚举名称获取对应的枚举code
     *
     * @param enums 枚举列表
     * @param name  枚举名
     * @return 枚举code
     */
    public static <T> T getCodeByName(NameCodeEnum<T>[] enums, String name) {
        if (StringUtils.isEmpty(name)) {
            return null;
        }
        for (NameCodeEnum<T> e : enums) {
            if (name.equals(e.getName())) {
                return e.getCode();
            }
        }
        return null;
    }

    /**
     * 根据枚举值获取对应的枚举对象
     *
     * @param enums 枚举列表
     * @return 枚举对象
     */
    @SuppressWarnings("unchecked")
    public static <E extends Enum<? extends CodeEnum<V>>, V> E getEnumByCode(E[] enums, V code) {
        for (E e : enums) {
            if (((CodeEnum<V>) e).getCode().equals(code)) {
                return e;
            }
        }
        return null;
    }

    /**
     * 根据枚举值获取对应的枚举对象
     *
     * @param enumClass 枚举class
     * @return 枚举对象
     */
    public static <E extends Enum<? extends CodeEnum<V>>, V> E getEnumByCode(Class<E> enumClass, V Code) {
        return getEnumByCode(enumClass.getEnumConstants(), Code);
    }
    
}
渣渣敲代码
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 枚举学习心得
08-19
java 枚举 学习心得
为什么建议你使用枚举？
一个程序员的成长
06-23 867
枚举是 JDK 1.5 新增的数据类型，使用枚举我们可以很好的描述一些特定的业务场景，比如一年中的春、夏、秋、冬，还有每周的周一到周天，还有各种颜色，以及可以用它来描述一些状态信息，比如...
枚举的使用
gaoyu0914的博客
10-25 1717
枚举的介绍和使用
Java枚举学习心得
学习笔记。
04-25 204
  在学习枚举前，我们不得不了解一下一下多例设计模式，多例模式是为了限制本类实例化对象的产生个数   多例设计模式的特点：构造方法私有化，类内部需要提供若干个实例化对象，后面过static方法返回。 eg. /* 定义一个描述颜色的多例类(表示有限个数的对象的类)， 构造方法私有化以后在类的内部提供对象 ...
黑马程序员_java枚举的学习心得
ICAN1112233的专栏
06-06 372
------------------------ android培训、java培训、期待与您交流！ ---------------------- 枚举的学习心得总结 枚举是1.5的新特性。在JDK1.5 之前，我们定义常量都是： public static final…… .现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。　publ
Java枚举技术心得
cchenxiran的专栏
07-11 199
黑马程序员  陈德龙   假使我们要做一个黑马教师管理的系统，那老师是不是只能是在黑马里面任职的，假使老师只有“张孝祥，黎活明，方立勋，冯威，徐培成”这些，那么除了他们就再不能出现别的老师名字了，因为我们黑马的老师就只有他们，所以这些老师是不是都是固定的而且不能有多余的其他的老师
枚举的7种使用方法
lijianjh的专栏
05-26 763
方法/步骤 　　用法一：常量 　　在JDK1.5之前，我们定义常量都是：publicstaticfianl....。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。 　　Java代码 　　public enum Color { 　　RED, GREEN, BLANK, YELLOW 　　} 　　用法二：sw
JAVA枚举类型学习心得
fcy98的专栏
06-02 782
<br />1.枚举类型的声明用emun关键字<br />2.没去类型可以定义一个枚举类型的文件也可以放在class类下面，1是枚举类2是定义在class类的枚举变量<br />     1.public enum Action {<br />              TRUE_LEFT,<br />              TRUE_RIGHT,<br />              SHOOT<br />          }<br />      2.private enum InnetEnum{
Java学习笔记7.0
11-01
《Java JDK6学习笔记》是作者良葛格本人近几年来学习Java的心得笔记，结构按照作者的学习脉络依次展开，从什么是Java、如何配置Java开发环境、基本的Java语法到程序流程控制、管理类文件、异常处理、枚举类型、泛型...
SwordToOffer:剑指offer（java版）使用Java实现剑指offer的大部分代码。已在牛客网OJ中AC，建议大家到牛客网OJ实践这部分内容
05-09
但是不保证我说的思路都是正确的，个人对算法也不是特别在行，只不过这本书的算法多看了几遍多做了几遍多了点心得体会。于是想总结一下。如果有错误也希望能指出，谢谢。具体代码可以参考我的GitHub仓库：节选剑指...
Java 高级特性.doc
05-30
学习心得：先从这四个知识点来看，张老师的确很让人敬佩！以上的一些程序代码均为张老师课堂即兴发挥所写，也可以看出，张老师对JAVA特性的深刻理解能力！现在说说我对这些程序代码的理解，说实话，才开始听张老师讲...
Java学习笔记(必看经典)
01-04
本书是作者近几年来学习Java的心得笔记，结构按照作者的学习脉络依次展开，从什么是Java、如何配置Java开发环境、基本的Java语法到程序流程控制、管理类文件、异常处理、枚举类型、泛型、J2SE中标准的API等均进行了...
代码中枚举的使用总结（供调试）
陌上花开缓缓归以的博客
04-16 230
1，我们在项目中很多时候用到枚举，那么我们在工程中怎么用到枚举呢,如果传入的参数是整形数据，那么我们要怎么办呢（强制类型转换） typedef enum { failure, success }STATE; int fun(STATE sta) { printf("fun = %s,line = %d,sta = %d\n",__FUNCTION__,__LINE__,sta); switch(sta) { case failure:
Java 枚举
weixin_33774883的博客
11-24 846
Java 枚举 知识点 概念 enum 的全称为 enumeration， 是 JDK 1.5 中引入的新特性。 在Java中，被 enum 关键字修饰的类型就是枚举类型。形式如下： enum Color { RED, GREEN, BLUE } 如果枚举不添加任何方法，枚举值默认为从0开始的有序数值。以 Color 枚举类型举例，它的枚举常量依次为 ...
C：enum(枚举)
weixin_43731793的博客
12-23 313
enum(枚举) https://www.runoob.com/cprogramming/c-enum.html #include <stdio.h> #include <stdlib.h> int main() { enum color { red=1, green, blue }; enum color favorite_color; ...
枚举的使用介绍
小程的博客
12-10 1281
枚举就是列举 ，特点： 1.枚举类型就是受到限制的有符号整型类型； 2.枚举值(元素)必须是整型； 3.枚举变量的取值必须是枚举值的集合 枚举的应用场景; 如果你需要定义一个有限制的整型变量，比如你想表示周一到周天，那么你可能需要定义一个整型变量取值范围只能是1-7 ...
java 枚举使用threadlocal
最新发布
07-28
Java中的枚举类型可以与ThreadLocal一起使用。ThreadLocal是一种线程局部变量，它为每个线程提供了一个独立的变量副本。通过将ThreadLocal与枚举类型结合使用，可以确保每个线程都有自己的枚举实例。 在Java中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值