java 枚举常见用法

用法一：常量

　　在JDK1.5 之前，我们定义常量都是： public static fianl.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。

public enum Color {  
   RED, GREEN, BLANK, YELLOW  
​​​​​​​ }  

用法二：switch

　JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。 

package com;

public class Test {
    enum Signal {
        GREEN, YELLOW, RED
    }

    public static void main(String[] args)
    {
        Signal color = Signal.RED;

        switch (color) 
        {
            case RED:
                System.out.println("您选择了红色");
                break;
            case YELLOW:
                System.out.println("您选择了黄色");
                break;
            case GREEN:
                System.out.println("您选择了绿色");
                break;
        }
    }
}

用法三：向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。 

public enum Color {  
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
    // 成员变量  
    private String name;  
    private int index;  
    // 构造方法  
    private Color(String name, int index) {  
        this.name = name;  
        this.index = index;  
    }  
    // 普通方法  
    public static String getName(int index) {  
        for (Color c : Color.values()) {  
            if (c.getIndex() == index) {  
                return c.name;  
            }  
        }  
        return null;  
    }  
    // get set 方法  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public int getIndex() {  
        return index;  
    }  
    public void setIndex(int index) {  
        this.index = index;  
    }  
}

 

用法四：覆盖枚举的方法

下面给出一个toString()方法覆盖的例子。 

public enum Color {  
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
    // 成员变量  
    private String name;  
    private int index;  
    // 构造方法  
    private Color(String name, int index) {  
        this.name = name;  
        this.index = index;  
    }  
    //覆盖方法  
    @Override  
    public String toString() {  
        return this.index+"_"+this.name;  
    }  
}  

 

用法五：实现接口

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。 

public interface Behaviour {  
    void print();  
    String getInfo();  
}  
public enum Color implements Behaviour{  
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
    // 成员变量  
    private String name;  
    private int index;  
    // 构造方法  
    private Color(String name, int index) {  
        this.name = name;  
        this.index = index;  
    }  
//接口方法  
    @Override  
    public String getInfo() {  
        return this.name;  
    }  
    //接口方法  
    @Override  
    public void print() {  
        System.out.println(this.index+":"+this.name);  
    }  
}

用法六：使用接口组织枚举

public interface Food {  
    enum Coffee implements Food{  
        BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
    }  
    enum Dessert implements Food{  
        FRUIT, CAKE, GELATO  
    }  
}  

 

下面我们自己使用一下枚举

一、先创建两个枚举

/** 
     * 季节枚举(不带参数的枚举常量)这个是最简单的枚举使用实例 
     * Ordinal 属性，对应的就是排列顺序，从0开始。 
     */
enum SimpleEnum 
{  
     SPRING,  
     SUMMER,  
     AUTUMN,  
     WINTER  
}  

package com;

/** 
     * 常用类型(带参数的枚举常量，这个只是在书上不常见，实际使用还是很多的，看懂这个，使用就不是问题啦。) 
     */  
enum TYPE 
{  
    FIREWALL("firewall"),  
    SECRET("secretMac"),  
    BALANCE("f5");  

    private String typeName;  

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

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

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

 二、测试

package com;

public class EnumTest 
{
    public static void main(String[] args) 
    {  
        forEnum();
        useEnumInJava();
    }  
  
    /** 
     * 循环枚举,输出ordinal属性；若枚举有内部属性，则也输出。(说的就是我定义的TYPE类型的枚举的typeName属性) 
     */  
    private static void forEnum()
    {
        for (SimpleEnum simpleEnum : SimpleEnum.values()) {
            System.out.println(simpleEnum + "  ordinal  " + simpleEnum.ordinal());
        }
        System.out.println("------------------");
        for (TYPE type : TYPE.values()) {
            System.out.println("type = " + type +
                    "    type.name = " + type.name() +
                    "   typeName = " + type.getTypeName() +
                    "   ordinal = " + type.ordinal());
        }
    }

    /**
     * 在Java代码使用枚举
     */
    private static void useEnumInJava()
    {
        String typeName = "f5";
        TYPE type = TYPE.fromTypeName(typeName);
        if (TYPE.BALANCE.equals(type)) {
            System.out.println("根据字符串获得的枚举类型实例跟枚举常量一致");
        } else {
            System.out.println("大师兄代码错误");
        }
    }
}

测试结果

 

看完这个枚举，你要懂个概念，那就是，这个枚举，他是个对象，就像你定义的Student类，Person类，等等一些个类一样。只要是个类，他就可以有构造函数，可以有属性，可以有方法。

然后，你就看到，这个地方有2个默认的属性，一个是name，一个是ordinal，这2个属性就像你定义Student类和Person类的name和age一样，只不过，这2个是继承枚举的属性，不用你自己去定义

你也可以给这个枚举类，也就是你自己声明的枚举，随便加属性。

我上面代码例子里面的那个TypeEnum那个枚举，就是这么干的，就简单的添加了个自定义属性typeName，

虽然他有自己的name了，那姑且叫我这个自定义的属性叫别名吧。

可以看到，我例子里面就是通过自己写的那个构造方法给我这个自定义的属性初始化值的。

还有，这个构造方法是不可以，也不被运行public的，不信，你可以试试。

还有，你不能对系统自带的name属性，在构造函数里面赋值