Java 枚举

注：文章内容大量借鉴使用网上的资料，可惜没有记录参考地址，只能再传对作者说声抱歉并表示感谢！

 

一 基础

1）语法

•      枚举类型只能有私有构造器（这样做可以保证客户代码没有办法新建一个enum的实例）
•      枚举实例必须最先定义

2）特性

•      所有枚举实例都是public , static , final
•      实例存在顺序，定义从上倒下，顺序从0开始
•      可以实现接口，不能继承类（默认集成:java.lang.Enum<E extends Enum<E>>）

3）样例

interface IEnum{
     public String getInfo();
}
/**
 * 枚举同类对比测试
 *
 * @author shilei
 *
 */
// 0 可以实现接口
public enum EnumBasic implements IEnum {
     // 1 枚举实例必须最先定义
     // 2 实例存在顺序，定义从上倒下，顺序从0开始
     // 3 所有枚举实例都是public , static , final
     // 等价于public static final EnumClass EnumInstance = new EnumClass("helllo enum!");
     Enum1( "helllo enum1!") {

           @Override
           public String getInfo() {
               return getAttr();
          }

     },
     Enum2( "helllo enum2!") {

           @Override
           public String getInfo() {
               return getAttr();
          }

     };

     private String attr;

     public String getAttr() {
           return attr ;
     }

     // 4 构造器必须是私有的
     private EnumBasic(String attr) {
           this.attr = attr;
     }

     public static void main(String[] args) {
           for (EnumBasic e : EnumBasic.values()) {
              System. out.println(e + "(" + e.ordinal() + ") : " + e.getAttr());
          }
     }
}

  二 本质

等价类：

interface IEnum {
     public String getInfo();
}
/**
 * EnumBasic 枚举类型等价类
 *
 * @author shilei
 *
 */
abstract class EnumClass implements IEnum {
     // Enum1("helllo enum2!")
     public static final EnumClass Enum1 = new EnumClass("helllo enum2!" ){

           @Override
           public String getInfo() {
               return getAttr();
          }
     
     };
     // Enum1("helllo enum2!")
     public static final EnumClass Enum2 = new EnumClass("helllo enum2!" ){

           @Override
           public String getInfo() {
               return getAttr();
          }
          
     };

     private String attr;

     public String getAttr() {
           return attr ;
     }

     private EnumClass(String attr) {
           this.attr = attr;
     }
}

  三 应用场景

用法一：常量

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

 

 

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

 

 

用法二：switch

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

 

enum Signal {
        GREEN, YELLOW, RED
    }

    public class TrafficLight {
        Signal color = Signal.RED;

        public void change() {
            switch (color) {
            case RED:
                color = Signal.GREEN;
                break;
            case YELLOW:
                color = Signal.RED;
                break;
            case GREEN:
                color = Signal.YELLOW;
                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 class Test {
    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;
        }
    }

    public static void main(String[] args) {
        System.out.println(Color.RED.toString());
    }
}

 

用法五：实现接口

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

 

ublic 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
        }
    }

用法七：关于枚举集合的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复;EnumMap中的 key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档

 

四 枚举和常量定义的区别

1） 通常定义常量方法

我们通常利用public final static方法定义的代码如下，分别用1表示红灯，3表示绿灯，2表示黄灯。

 

public class Light {
        /* 红灯 */
        public final static int RED = 1;

        /* 绿灯 */
        public final static int GREEN = 3;

        /* 黄灯 */
        public final static int YELLOW = 2;
    }

 

2） 枚举类型定义常量方法

枚举类型的简单定义方法如下，我们似乎没办法定义每个枚举类型的值。比如我们定义红灯、绿灯和黄灯的代码可能如下：

 

public enum Light {
        RED, GREEN, YELLOW;
 }

 

我们只能够表示出红灯、绿灯和黄灯，但是具体的值我们没办法表示出来。别急，既然枚举类型提供了构造函数，我们可以通过构造函数和覆写toString方法来实现。首先给Light枚举类型增加构造方法，然后每个枚举类型的值通过构造函数传入对应的参数，同时覆写toString方法，在该方法中返回从构造函数中传入的参数，改造后的代码如下：

 

public enum Light {

    // 利用构造函数传参
    RED(1), GREEN(3), YELLOW(2);

    // 定义私有变量
    private int nCode;

    // 构造函数，枚举类型只能为私有
    private Light(int _nCode) {

        this.nCode = _nCode;

    }

    @Override
    public String toString() {

        return String.valueOf(this.nCode);

    }

}