Java--枚举(enum)--使用/教程/实例

一枚路过的程序猿

 关注

阅读 67

2022-02-15


简介

说明

        本文用示例介绍Java中的枚举（enum）的用法。

使用场景

定义常量、状态机等。

枚举与常量类

常量类

        以往设置常量，通常将常量放置在接口中，这样在程序中就可以直接使用了，并且该常量不能被修改，因为在接口中定义的常量时，该常量的修饰符为final与static。如：

public interface IConstants{
  public static final int RED = 1;
  public static final int BLUE = 2;
  public static final int GREEN = 3;
}

枚举与常量类的对比

项

枚举类

常量类

单例


完全单例、线程安全。

枚举类编译后类为：public final class T extends Enum，不允许继承可防止被子类修改。



不单例

常量类可被继承修改、增加字段等，容易导致父类的不兼容。


性能


性能高。

常量值地址唯一，可以用==直接对比



性能低

使用常量类时，往往得通过equals去判断两者是否相等。


引用类


不需重新编译引用类。

枚举类编译时，没有把常量值编译到代码里，即使常量的值发生变化，也不会影响引用常量的类。



需要重新编译引用类。

常量类编译时，是直接把常量的值编译到类的二进制代码里，常量的值在升级中变化后，需要重新编译引用常量的类，因为里面存的是旧值。


越界


不会越界。

编译期间限定类型，不允许发生越界的情况。



可能越界。

switch语句支持枚举型，当switch使用int、String类型时，由于值的不稳定性往往会有越界的现象，对于这个的处理往往只能通过if条件筛选以及default模块来处理。


枚举与普通类

差别不大。枚举也可以定义变量与方法：

package org.example.a;

enum MyEnum{
    FIRST("第一个"),
    SECOND("第二个"),
    ;

    private String desc;
    private MyEnum(String desc) {
        this.desc = desc;
    }

    public String getDesc() {
        return desc;
    }

    private String lastName;

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

public class Demo {
    public static void main(String[] args) {
        MyEnum.FIRST.setLastName("Tony");
        System.out.println(MyEnum.FIRST.getLastName());
        System.out.println(MyEnum.FIRST.getDesc());
    }
}

执行结果

Tony
第一个

枚举与数据库

        枚举型可以直接与数据库打交道，我通常使用varchar类型存储，对应的是枚举项的名字。

        在下边的例子中，如果某个类中的字段为：private PersonType type; 则其对应的数据库中的值为："STUDENT"、"TEACHER"。

enum PersonType{
    STUDENT("学生"),
    TEACHER("教师"),
    ;

    private String desc;
    private People(String desc) {
        this.desc = desc;
    }

    public String getDesc() {
        return desc;
    }
}

基础示例

一个参数​

实例 

package org.example.a;

enum PayTypeEnum{
    ALIPAY("支付宝"),
    WECHAT("微信"),
    UNIONPAY("银联"),
    ;

    //这个必须定义，且成员变量的类型及个数必须对应于上边枚举的定义
    //枚举标识码（英文描述）
    private String desc;

    //必须提供。私有防外部new对象的
    private PayTypeEnum(String desc) {
        this.desc = desc;
    }

    public String getDesc() {
        return desc;
    }
}

public class Demo {
    public static void main(String[] args){
        for (PayTypeEnum value : PayTypeEnum.values()) {
            System.out.println("name:" + value.name() + "," + "desc:" + value.getDesc());
//            下边这样写结果是一样的
//            System.out.println("name:" + value.toString() + "," + "desc:" + value.getDesc());
        }
    }
}

运行结果

name:ALIPAY,desc:支付宝
name:WECHAT,desc:微信
name:UNIONPAY,desc:银联

多个参数

其他网址

​​面试官：java枚举你实际开发中怎么用 程序员：我用常量啊​​

实例 

package org.example.a;

interface IEnum{
    String getCode();
    String getDesc();
}

enum PayTypeEnum implements IEnum{
    ALIPAY("ALIPAY", "支付宝"),
    WECHAT("WECHAT", "微信"),
    UNIONPAY("UNIONPAY", "银联"),
    ;

    //这个必须定义，且成员变量的类型及个数必须对应于上边枚举的定义
    //枚举标识码（英文描述）
    private String code;
    //枚举标识码（中文描述）
    private String desc;

    //必须提供。私有防外部new对象的
    private PayTypeEnum(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public static String getDescByCode(String code){
        for(PayTypeEnum value : PayTypeEnum.values()){
            if(value.getCode().equals(code)){
                return value.getDesc();
            }
        }
        return null;
    }

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

    @Override
    public String getDesc() {
        return this.desc;
    }
}

public class Demo {
    public static void main(String[] args){
        System.out.println(PayTypeEnum.getDescByCode(PayTypeEnum.ALIPAY.getCode()));
        System.out.println(PayTypeEnum.getDescByCode(PayTypeEnum.WECHAT.getCode()));
    }
}

运行结果

支付宝
微信

异常处理应用

其他网址

​​java开发中异常怎么定义好 程序员：不知道​​

异常码枚举

package enums.expection;
import org.apache.commons.lang.StringUtils;

public enum ErrorCodeEnum {
    SYS_ERROR("SYS_ERROR", "系统错误，请重试"),
    UNKNOWN_ERROR("UNKNOWN_SYS_ERROR", "未知的系统异常"),
    SERVICE_INVOKE_FAIL("SERVICE_INVOKE_FAIL", "服务调用失败"),
    ILLEGAL_ARGS("ILLEGAL_ARGS", "参数校验错误"),
    ;
    public static ErrorCodeEnum getByValue(String code) {
        for (ErrorCodeEnum result : values()) {
            System.out.println(result.ordinal());
            if (StringUtils.equals(result.getCode(), code)) {
                return result;
            }
        }
        return null;
    }
    /**
     * 结果码值.
     */
    private String code;
    /**
     * 描述.
     */
    private String desc;

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

    public String getCode() {
        return code;
    }

    public String getDesc() {
        return desc;
    }
    public void setDesc(String desc) {
        this.desc = desc;
    }

}

自定义异常

package enums.expection;

import org.apache.commons.lang.StringUtils;

import java.util.HashMap;
import java.util.Map;

public  class WangException extends RuntimeException {
    private static final long serialVersionUID = -8581672033133636908L;
    /*** 错误码枚举*/
    private ErrorCodeEnum errorCode;
    /**
     * 详细错误信息
     */
    private Map<String, String> errorMap = new HashMap<String, String>();
    /**
     * 带参构造器.
     *
     * @param errorCode
     */
    public WangException(ErrorCodeEnum errorCode) {
        super(errorCode.getDesc());
        this.setErrorCode(errorCode);
    }
    /**
     * 带参构造器.
     *
     * @param errorCode
     * @param message
     */
    public WangException(ErrorCodeEnum errorCode, String message) {
        super(StringUtils.isNotBlank(message) ? message : errorCode.getDesc());
        this.setErrorCode(errorCode);
    }

    /**
     * 带参构造器.
     *
     * @param errorCode
     * @param errorMap
     */
    public WangException(ErrorCodeEnum errorCode, Map<String, String> errorMap) {
        this(errorCode);
        this.errorMap = errorMap;
    }
    /**
     * 带参构造器.
     *
     * @param message
     */
    public WangException(String message) {
        super(message);
        this.setErrorCode(ErrorCodeEnum.UNKNOWN_ERROR);
    }
    /**
     * Gets error code.
     *
     * @return the error code
     */
    public ErrorCodeEnum getErrorCode() {
        return errorCode;
    }
    /**
     * Sets error code.
     *
     * @param errorCode the error code
     */
    public void setErrorCode(ErrorCodeEnum errorCode) {
        this.errorCode = errorCode;
    }
    /**
     * Gets error map.
     *
     * @return the error map
     */
    public Map<String, String> getErrorMap() {
        return errorMap;
    }
    /**
     * Sets error map.
     *
     * @param errorMap the error map
     */
    public void setErrorMap(Map<String, String> errorMap) {
        this.errorMap = errorMap;
    }
    private static String findMessage(Map<String, String> errorMap) {
        if (errorMap.isEmpty()) {
            return null;
        }
        return errorMap.values().iterator().next();
    }

}

测试类

package enums.expection;

public class Test {

    public static void main(String[] args) {
        String name="";
        int i=0;
        try {
            if (name == null)
                throw new WangException(ErrorCodeEnum.ILLEGAL_ARGS);
            if(i==0)
                throw new WangException(ErrorCodeEnum.ILLEGAL_ARGS,"参数不能为0");
        }catch (WangException e){
            e.printStackTrace();
            System.out.println("异常码："+e.getErrorCode().getCode());
            System.out.println("异常描述："+e.getMessage());
        }
    }
}

高级操作

接口中定义注解

package org.example.a;

interface Color {
    enum Green {LIGHT_GREEN, DARK_GREEN}
    enum Red {LIGHT_RED, DARK_RED}
}

public class Demo {
    public static void main(String[] args) {
        System.out.println(Color.Green.DARK_GREEN.ordinal());
    }
}

执行结果

1

枚举上使用注解​

实现原理

其他网址

​​深度分析Java的枚举类型—-枚举的线程安全性及序列化问题-HollisChuang's Blog​​

枚举类

package org.example.a;

public enum Season {
    SPRING, SUMMER, AUTUMN, WINTER;
}

反编译代码

public final class Season extends Enum
{
    private Season(String s, int i)
    {
        super(s, i);
    }
    public static Season[] values()
    {
        Season at[];
        int i;
        Season at1[];
        System.arraycopy(at = ENUM$VALUES, 0, at1 = new Season[i = at.length], 0, i);
        return at1;
    }

    public static Season valueOf(String s)
    {
        return (Season)Enum.valueOf(demo/Season, s);
    }

    public static final Season SPRING;
    public static final Season SUMMER;
    public static final Season AUTUMN;
    public static final Season WINTER;
    private static final Season ENUM$VALUES[];
    static
    {
        SPRING = new Season("SPRING", 0);
        SUMMER = new Season("SUMMER", 1);
        AUTUMN = new Season("AUTUMN", 2);
        WINTER = new Season("WINTER", 3);
        ENUM$VALUES = (new Season[] {
            SPRING, SUMMER, AUTUMN, WINTER
        });
    }
}

分析

通过反编译后代码可见，该类继承了Enum类，同时final关键字表明这个类不能被继承。

字段都是static类型的，static类型的属性会在类被加载之后被初始化。当一个Java类第一次被真正使用到的时候静态资源被初始化、Java类的加载和初始化过程都是线程安全的。所以，创建一个enum类型是线程安全的。

相关推荐

Java--常用库函数--使用/教程/实例

A邱凌 75 0 0

java Enum 枚举

金牛豆豆 103 0 0

Java枚举(enum)

小暴龙要抱抱 53 0 0

java枚举（enum）

敬亭阁主 95 0 0

Java教程 第29章 枚举(enum)

女侠展昭 93 0 0

枚举Enum使用

天际孤狼 41 0 0

Java enum枚举配合switch使用

橙子好吃吗 75 0 0

java枚举类型enum的使用

架构大数据双料架构师 125 0 0

Java进阶：枚举enum

流沙雨帘 76 0 0

使用枚举（Enum）利与弊

E_topia 83 0 0

精彩评论（0）

0 0 举报