Java 优雅的java枚举类

Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等。

Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。

定义一个简易枚举类：

public enum YesNo1Enum {

    YES, NO;

    //颜色：RED, WHITE, GREEN;
    //星期：MON, TUE, WEN;
}

//调用
public class Test {

    public static void main(String[] args) {

        System.out.println(YesNo1Enum.YES);

    }
}

输出结果：  YES  

定义一个可以获取code值的枚举：

public enum YesNo2Enum {

    YES("1"),
    NO("0");

    private String code;

    YesNo2Enum(String code){
        this.code = code;
    }

    public String getCode(){
        return code;
    }

    public void setCode(String code){
        this.code = code;
    }
}

//调用
public class Test {

    public static void main(String[] args) {

        System.out.println(YesNo2Enum.YES);
        System.out.println(YesNo2Enum.YES.getCode());

    }
}

输出结果：  YES  

                       1     

 定义一个可以获取code值和desc的枚举：

public enum YesNo3Enum {

    YES("1","是"),
    NO("0","否");

    private String code;
    private String desc;

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

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getDesc() {
        return desc;
    }

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

}

//调用
public class Test {

    public static void main(String[] args) {

        System.out.println(YesNo3Enum.YES);
        System.out.println(YesNo3Enum.YES.getCode());
        System.out.println(YesNo3Enum.YES.getDesc());

    }
}

输出结果：    YES   

                        1      

                        是     

定义一个中文显示的枚举：

public enum YesNo4Enum {

    是("1"),
    否("0");

    private String code;

    YesNo4Enum(String code){
        this.code = code;
    }

    public String getCode(){
        return code;
    }

    public void setCode(String code){
        this.code = code;
    }

}

//调用
public class Test {

    public static void main(String[] args) {

        System.out.println(YesNo4Enum.是);
        System.out.println(YesNo4Enum.否.getCode());

    }
}

输出结果：    是    

                       0    

public enum PayEnum {

    //枚举项，采用全部大写命名
    //枚举项就是一个一个对象，它是常量，可定义枚举项的时候调用构造方法
    WEIXINPAY("weixin", "https://api.mch.weixin.qq.com/pay/"),
    ALIPAY("ali", "https://openapi.alipay.com/"),
    UNIONPAY("union", "https://gateway.95516.com/gateway/api/");

    private String name;//支付名称
    private String url;//支付地址

    PayEnum(String name, String url) {
        this.name = name;
        this.url = url;
    }

    public String getName() {
        return name;
    }

    public String getUrl() {
        return url;
    }

}

//调用
public class Test {

    public static void main(String[] args) {

        //枚举项就是一个对象（实例）
        PayEnum weixinPay = PayEnum.ALIPAY;
        System.out.println(weixinPay.getName());
        System.out.println(weixinPay.getUrl());

    }
}

输出结果：    ali    

                       https://openapi.alipay.com/    

values(), ordinal() 和 valueOf() 方法

enum 定义的枚举类默认继承了 java.lang.Enum 类，并实现了 java.lang.Serializable 和 java.lang.Comparable 两个接口。

values(), ordinal() 和 valueOf() 方法位于 java.lang.Enum 类中：

• values() 返回枚举类中所有的值。
• ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样。
• valueOf()方法返回指定字符串值的枚举常量。

enum Color { 
    RED, GREEN, BLUE; 
} 
  
public class Test { 
    public static void main(String[] args) { 
        // 调用 values() 
        Color[] arr = Color.values(); 
  
        // 迭代枚举
        for (Color col : arr) { 
            // 查看索引
            System.out.println(col + " at index " + col.ordinal()); 
        } 
  
        // 使用 valueOf() 返回枚举常量，不存在的会报错 IllegalArgumentException 
        System.out.println(Color.valueOf("RED")); 
        // System.out.println(Color.valueOf("WHITE")); 
    } 
} 

 输出结果：       RED at index 0      

                        GREEN at index 1   

                           BLUE at index 2   

                                   RED              

枚举类成员

枚举跟普通类一样可以用自己的变量、方法和构造函数，构造函数只能使用 private 访问修饰符，所以外部无法调用。

枚举既可以包含具体方法，也可以包含抽象方法。 如果枚举类具有抽象方法，则枚举类的每个实例都必须实现它。

enum Color { 
    RED, GREEN, BLUE; 
  
    // 构造函数
    private Color() { 
        System.out.println("Constructor called for : " + this.toString()); 
    } 
  
    public void colorInfo(){ 
        System.out.println("Universal Color"); 
    } 
} 
  
public class Test {     
    // 输出
    public static void main(String[] args) { 
        Color c1 = Color.RED; 
        System.out.println(c1); 
        c1.colorInfo(); 
    } 
} 

输出结果            Constructor called for : RED         

                        Constructor called for : GREEN      

                           Constructor called for : BLUE      

                                             RED                           

                                    Universal Color                   

 使用 for 语句来迭代枚举元素：

enum Color { 
    RED, GREEN, BLUE; 
} 
public class MyClass { 
  public static void main(String[] args) { 
    for (Color myVar : Color.values()) {
      System.out.println(myVar);
    }
  } 
}

输出结果                  RED          

                               GREEN       

                                BLUE