Java--枚举

枚举的背景和定义

枚举是在JDK1.5以后引入的。主要用途是：将一组常量组织起来，在这之前表示一组常量通常使用定义常量的方式：

public static int final RED = 1; 
public static int final GREEN = 2; 
public static int final BLACK = 3;

但是常量举例有不好的地方，例如：可能碰巧有个数字1，但是他有可能误会为是RED，现在我们可以直接用枚举来进行组织，这样一来，就拥有了类型，枚举类型。而不是普通的整形1.

public enum TestEnum { 
	RED,BLACK,GREEN;
}

优点：将常量组织起来统一进行管理
使用场景：错误状态码，消息类型，颜色的划分，状态机等等…
本质：是java.lang.Enum的子类（也就是说自己写的枚举类都默认继承了这个类）

枚举的使用

switch

public enum TestEnum { 
	RED,BLACK,GREEN,WHITE;
	public static void main(String[] args) { 
		TestEnum testEnum2 = TestEnum.BLACK; switch (testEnum2) {
			case RED:
				System.out.println("red"); 
				break;
			case BLACK:
				System.out.println("black");
				 break;
			case WHITE:
				System.out.println("WHITE"); 
				break;
			case GREEN:
				System.out.println("black");
			break; default:
				break;
		}
	}
}

常用的方法

Enum中的常用方法

举例

    public static void main(String[] args) {
        //将当前的枚举对象，封装为数组
        TestEnum[] testEnums = TestEnum.values();
       /* for (TestEnum testEnum :testEnums) {
            System.out.println(testEnum);
        }*/
        for (int i = 0; i < testEnums.length; i++) {
            System.out.println(testEnums[i].ordinal());
        }
        //根据字符串解析出来一个枚举对象
        System.out.println(TestEnum.valueOf("GREEN"));
        //比较
        System.out.println(RED.compareTo(BLACK));
    }

枚举和反射

在此之前我们要明确一点：枚举中的构造方法默认是私有的。
但是任何一个类，哪怕其构造方法是私有的，我们也可以通过反射拿到他的实例对象，那 么枚举的构造方法也是私有的，我们是否可以拿到呢？接下来，我们来实验一下：
同样利用上述提供的枚举类来进行举例：

public enum TestEnum {
    RED("red", 1), BLACK("black", 2), WHITE("white", 3), GREEN("green", 4);
    private String name;
    private int age;

    /**
     * 1、当枚举对象有参数后，需要提供相应的构造函数
     * 2、枚举的构造函数默认是私有的 这个一定要记住
     *
     * @param name
     * @param age
     */
    private TestEnum(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static TestEnum getEnumKey(int key) {
        for (TestEnum t : TestEnum.values()) {
            if (t.age == key) {
                return t;
            }

        }
        return null;
    }

    public static void reflectPrivateConstructor() {
        try {
            Class<?> classStudent = Class.forName("TestEnum");
            //注意传入对应的参数,获得对应的构造方法来构造对象,当前枚举类是提供了两个参数分别是String和int
            Constructor<?> declaredConstructorStudent = classStudent.getDeclaredConstructor(String.class, int.class);
            //设置为true后可修改访问权限
            declaredConstructorStudent.setAccessible(true);
            Object objectStudent = declaredConstructorStudent.newInstance("绿色", 666);
            TestEnum testEnum = (TestEnum) objectStudent;
            System.out.println("获得枚举的私有构造函数：" + testEnum);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectPrivateConstructor();
    }
}

输出结果：

异常信息是：java.lang.NoSuchMethodException: TestEnum.(java.lang.String,int) ,什么意思是：就是没有对应的构造方法，我的天呐！我们提供的枚举的构造方法就是两个参数分别是String 和 int 啊！！！！问题出现在哪里呢？还记不记得我们说过的，我们所有的枚举类，都是默认继承与java.lang.Enum ,说到继承，继承了什么？继承了父类除构造函数外的所有东西，并且子类要帮助父类进行构造！ 而我们写的类，并没有帮助父类构造！那意思是，我们要在自己的枚举类里面，提供super吗？不是的，枚举比较特殊，虽然我们写的是两个，但是默认他还需要添加了两个参数，哪两个参数呢？我们看一下Enum类的源码：

protected Enum(String name, int ordinal) { 
	this.name = name;
	this.ordinal = ordinal;
}

也就是说，我们自己的构造函数有两个参数一个是String一个是int，同时他默认后边还会给两个参数，一个是String一个是int。也就是说，这里我们正确给的是4个参数：
修改上面的代码

Constructor<?> declaredConstructorStudent =                   classStudent.getDeclaredConstructor(String.class, int.class,String.class,int.class);
//这里为了凑齐参数，后两个参数随便给，不给也行，默认为空值
Object objectStudent = declaredConstructorStudent.newInstance("绿色",666,"父类参数",888);

此时运行程序结果是：

嗯！没错，他还报错了，不过这次就是我们想要的结果！此时的异常信息显示，是我的一个方法这个方法是： newInstance() 报错了！没错，问题就是这里，我们来看一下这个方法的源码，为什么会抛出java.lang.IllegalArgumentException: 异常呢？
我们来看一下源码

可以看出，枚举在这里被过滤了，我们不能通过反射获取枚举类的实例！所以用枚举来实现单例模式是安全的。

相关面试题

写一个单例模式

public class Singleton {
    private volatile static Singleton uniqueInstance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {//进入区域后，再检查一次，如果仍是null,才创建实例
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

用静态内部类实现一个单例模式

class Singleton {
    /** 私 有 化 构 造 器 */ 
    private Singleton() {

    }
    /** 对外提供公共的访问方法 */
    public static Singleton getInstance() { 
        return UserSingletonHolder.INSTANCE;
    }

    /** 写一个静态内部类，里面实例化外部类 */ 
    private static class UserSingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
}
public class Main {
    public static void main(String[] args) { 
        Singleton u1 = Singleton.getInstance(); 
        Singleton u2 = Singleton.getInstance();
        System.out.println("两个实例是否相同："+ (u1==u2));
    }
}

用枚举实现一个单例模式

public enum TestEnum { 
	INSTANCE;
    public TestEnum getInstance(){ 
        return INSTANCE;
    }
    public static void main(String[] args) { 
        TestEnum singleton1=TestEnum.INSTANCE; 
        TestEnum singleton2=TestEnum.INSTANCE;
        System.out.println("两个实例是否相同："+(singleton1==singleton2));
    }
}

枚举的优缺点

优点：

• 1.枚举常量更简单安全 。
• 2.枚举具有内置方法 ，代码更优雅

缺点：

• 不可继承，无法扩展