java基础/枚举

枚举

在实际中对于一些基本固定的值用枚举比较好。

当然实际项目中可以用到2种方式：

1、做数据字典，方便对常量的添加，修改比较灵活，涉及大的项目工程时候选用数据字典较好；

2、使用java的枚举，比较适合小的项目，定义数据集。

一、枚举类型（Java枚举是一种类型）

定义枚举

/**
 *枚举是静态实例类的一种对象类型，已经实例化过，可以获取里面的一些数据
 */
public enum ColorEnum  {
    red,green,yellow,blue;
}

定义测试枚举类

public class TestEnum {
    public static void main(String[] args) throws Exception {
        ColorEnum blue=ColorEnum.blue;
        System.out.println(blue.getClass().getName());//com.package.ColorEnum
        System.out.println(blue.name());//blue
    }

枚举由Java普通类改写如下：

public class ColorE {
    //枚举名称
    private final String name="";

    public String getName() {
        return name;
    }
    //所以枚举是静态实例类的一种对象类型，已经实例化过，可以获取里面的一些数据
    public static final ColorE blue=new ColorE(){
        public String getName(){
            return "blue";
        };
    };
}

二、枚举参数&方法

方法一：

/**
 * 枚举中的参数是枚举类型上进行给自定义变量进行赋值的一个数据来源，
 * 用构造函数进行数据的封装，方法就是对每个赋值的数据进行获取
 */
public enum  Gender {
    //枚举参数
    MAN(0,"男"),WOMEN(1,"女");
   //自定义变量
    private final int value;//对应0和1
    private final String name;//对应男和女

    Gender(int value, String name) { //构造函数对数据进行封装
        this.value=value;
        this.name=name;
    }

    public int getValue() {
        return value;
    }

    public String getName() {
        return name;
    }
}

方法二：

/**
 * 对方法的重载，直接进行赋值，不需要用构造函数
 * */
public enum OrderState {
    /** 已取消 */
    CANCEL {public String getName(){return "已取消";}},
    /** 待审核 */
    WAITCONFIRM {public String getName(){return "待审核";}},
    /** 等待付款 */
    WAITPAYMENT {public String getName(){return "等待付款";}},
    /** 正在配货 */
    ADMEASUREPRODUCT {public String getName(){return "正在配货";}},
    /** 等待发货 */
    WAITDELIVER {public String getName(){return "等待发货";}},
    /** 已发货 */
    DELIVERED {public String getName(){return "已发货";}},
    /** 已收货 */
    RECEIVED {public String getName(){return "已收货";}};

    public abstract String getName();
}

二、遍历

枚举遍历常用方式：1.switch对单个枚举类型进行判断  2.for整体循环遍历

switch对单个枚举类型进行判断

public class TestEnum {
       public static void main(String[] args){
           Gender flag = Gender.MAN;
           switch(flag){
               case MAN:
                   System.out.println(flag.getName() + ":" + flag.getValue() + ":" + flag.ordinal());//男:0:0
                   break;
               case WOMEN:
                   System.out.println(flag.getName() + ":" + flag.getValue() + ":" + flag.ordinal());
                   break;
                default:
                   break;
           }
       }
}

for整体循环遍历

public class TestEnum {
       public static void main(String[] args){
          /**values是获取枚举类型数组*/
           for(Gender g : Gender.values()) {
               /**男:0:0
                * 女:1:1 */
               System.out.println(g.getName() + ":" + g.getValue() + ":" + g.ordinal());
           }
       }
}

注意：ordinal()是枚举定义的枚举类型的下标数，默认从0开始。values()是获取枚举类型数组

项目实际应用

public enum EnumTest{

    THING_OF_YARD(1, "一物一码"),

    BATCH_OF_YARD(2, "一批一码"),

    SINGLEPRO_OF_YARD(3, "一箱一码"),

    private int    value;
    private String name;

    EnumTest(int value, String name) {
        this.value = value;
        this.name = name;
    }

    public int getValue() {
        return value;
    }

    public String getName() {
        return name;
    }     
      
    //根据传入的name比较是否与枚举参数名一致
    public static Integer getValueByName(String name){
        for(EnumTest skuTraceType : EnumTest.values()){
            if(StringUtils.equals(name, skuTraceType.getName())){
                return skuTraceType.getValue();
            }
        }
        return null;
    }
}

测试

public class TestEnum {
       public static void main(String[] args){
           int test=EnumTest.getValueByName("一物一码");//1
           System.out.println(test);//1
           for (EnumTest traceType : EnumTest.values()){
               System.out.println(traceType.getValue());//1 & 2 & 3
               System.out.println(traceType.getName());//一物一码 &一批一码 & 一箱一码
           }
       }
}

参考博客：http://blog.csdn.net/fengchao2016/article/details/52756366