枚举

一、概述

一、枚举型常量

首先枚举是一个特殊的class，这个class相当于final static修饰，不能被继承；
所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类;
他的构造方法强制被私有化，下面有一个默认的构造方法private ColorEnum();

/**
 * 每个枚举变量都是枚举类ColorEnum的实例，相当于RED=new ColorEnum（1），按序号来;
 * 每个成员变量都是final static修饰;
 */
enum ColorEnum {
    RED, GREEN, BLANK, YELLOW;
}

//测试
public class Test {
    public static void main(String[] args) {
        //ordinal返回枚举变量的序号
        for(ColorEnum color:ColorEnum.values()) {
            System.out.println(color+" ordinal:"+color.ordinal()+" name:"+color.name());
        }
//        RED    ordinal:0 name:RED
//        GREEN  ordinal:1 name:GREEN
//        BLANK  ordinal:2 name:BLANK
//        YELLOW ordinal:3 name:YELLOW
    }
}    

二、带一个参数的枚举

enum TypeEnum {

    FIREWALL("firewall"),  
    SECRET("secretMac"),  
    BALANCE("f5");  

    private String typeName;  

    TypeEnum(String typeName) {  
        this.typeName = typeName;  
    }  

    /** 
     * 根据类型的名称，返回类型的枚举实例。 
     * @param typeName 类型名称 
     */  
    public static TypeEnum fromTypeName(String typeName) {  
        for (TypeEnum type : TypeEnum.values()) {  
            if (type.getTypeName().equals(typeName)) {  
                return type;  
            }  
        }  
        return null;  
    }  

    public String getTypeName() {  
        return this.typeName;  
    }    
}

/**
 * 测试
 * type:是TypeEnum类实例化对象    
 * typeName：实例化对象type的值 
 * ordinal：实例化对象type的序号（int）, 排序值(默认自带的属性 ordinal 的值)
 * name：实化对象的名字（String）,枚举名称(即默认自带的属性 name 的值)
 */
public class Test {
    public static void main(String[] args) {
        String typeName = "f5";  
        TypeEnum type = TypeEnum.fromTypeName(typeName);
        
        System.out.println(type+",typeName:"+type.getTypeName()+",ordinal:"+type.ordinal()+",name:"+type.name());
        //BALANCE,typeName:f5,ordinal:2,name:BALANCE
    }
}

实际开发该怎么用呢？

package niing;

//状态封装 (0 禁用 1启用 2删除)
enum DataStatus {
    DISABLE("1")
    ,ENABLE("2")
    ,DELETE("3");

    private final String status;
    
    DataStatus(String status){
        this.status = status;
    }
    public String getStatus(){
        return this.status;
    }
}

public class Test {
    public static void main(String[] args) {
       //DataStatus.DELETE获得的枚举对象 相当于 new DataStatus("3") 获得的对象;
       System.out.println(DataStatus.DELETE); //DELETE
       //在实际开发中这样去获取枚举中定义的常量，这就好比以前在接口或者公共类中定义的 private statis final String DELETE = "2";
       System.out.println(DataStatus.DELETE.getStatus()); //3 
    }
}

三、向枚举中添加新方法

enum SeasonEunm {
    //每一个枚举变量都是枚举类SeasonEunm的实例化;
    //SeasonEunm.SPRING获得的对象相当于new SeasonEunm("春","春困") 获得的对象;
    SPRING("春","春困"),SUMMER("夏","夏睡"),AUTUMN("秋","秋乏"),WINTER("冬","冬眠");

    //强制私有化的构造方法，因为枚举类默认继承Eunm类，被final static修饰，不能被继承;
    //由于被强制private，所以不能使用new去生成枚举对象;
    //在SeasonEunm.SPRING获得对象，隐式调用了下面的构造方法;
    // 构造方法 ,赋值给成员变量
    private SeasonEunm(String name, String value) {
        this.name = name;
        this.value = value;
    }

    //添加成员变量的原因是，方便够着方法赋值，使用SeasonEunm.SPRING.getName就能获取对应的值;
    private String name;
    private String value;


    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
}

//测试
public class Test {
    public static void main(String[] args) {
        //ordinal返回枚举变量的序号
        for(SeasonEunm seasion:SeasonEunm.values()) {
            System.out.println(seasion+",ordinal:"+seasion.ordinal()+",name:"+seasion.name());
            System.out.println("枚举变量值:"+seasion.getName()+",枚举变量值:"+seasion.getValue());
        }
        
//        SPRING,ordinal:0,name:SPRING
//              枚举变量值:春,枚举变量值:春困
//        SUMMER,ordinal:1,name:SUMMER
//              枚举变量值:夏,枚举变量值:夏睡
//        AUTUMN,ordinal:2,name:AUTUMN
//              枚举变量值:秋,枚举变量值:秋乏
//        WINTER,ordinal:3,name:WINTER
//             枚举变量值:冬,枚举变量值:冬眠
    }
}

四、覆盖枚举的方法

enum RGBEnum {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
    // 成员变量  
    private String name;  
    private int index;  
    // 构造方法 ,赋值给成员变量
    private RGBEnum(String name, int index) {  
        this.name = name;  
        this.index = index;  
    }  

    //覆盖方法  :只能使用toString方法来输出枚举变量值
    @Override  
    public String toString() {  
        return this.index+"_"+this.name;  
    }  
}

//测试
public class Test {
    public static void main(String[] args) {
        for(RGBEnum rgb:RGBEnum.values()) {
            System.out.println(rgb.toString());
        }
//        1_红色
//        2_绿色
//        3_白色
//        4_黄色
    }
}

二、使用 

1. 根据值获取到枚举对象

定义了一个枚举：

@NoArgsConstructor
@AllArgsConstructor
@Getter
public enum StarEnum {
    LiuYiFei("刘亦菲", 23),
    ChenShu("陈数", 24),
    WangOu("王鸥", 25);

    private String name;
    private Integer age;
}

获取枚举对象：

package myEnum;

import org.apache.commons.lang3.EnumUtils;
import java.util.List;

/**
 * @author zls
 * @date 2020/3/6
 */
public class EnumTest {
    public static void main(String[] args) {
        List enumList = EnumUtils.getEnumList(StarEnum.class);
        System.out.println("enumList = " + enumList);
        // enumList = [LiuYiFei, ChenShu, WangOu]

        StarEnum chenShu = EnumUtils.getEnum(StarEnum.class, "ChenShu");
        System.out.println("chenShu = " + chenShu); // chenShu = ChenShu

    }
}

建议使用lang3提供的枚举工具类，而不要使用lang，使用lang会报错，此外，你也可以利用反射自己封装适用于自己的工具类。

转载：https://blog.csdn.net/newbie_907486852/article/details/81027512