Java——枚举

1. 概念

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

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

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

public enum TestEnum {
    RED,BLACK,GREEN;
}

优点：将常量组织起来统一管理

场景：错误状态码，消息类型，颜色的划分，状态机等等。。。

本质：是 java.lang.Enum 的子类，也就是说，自己写的枚举类型，就算没有显式继承Enum，但其默认继承了这个类

2. 使用

2.1 switch语句

示例：

public enum TestEnum {
    //枚举对象
    RED,BLACK,GREEN,WHITE;

    public static void main(String[] args) {
        TestEnum testEnum = RED;
        switch(testEnum) {
            case BLACK:
                System.out.println("BLACK");
                break;
            case RED:
                System.out.println("RED");
                break;
            case GREEN:
                System.out.println("GREEN");
                break;
            default:
                System.out.println("颜色错误");
                break;
        }
    }
}

2.2 常用方法

方法名称	描述
values()	以数组形式返回枚举类型的所有成员
ordinal()	获取枚举成员的索引位置
valueOf()	将普通字符串转换为枚举实例
compareTo()	比较两个枚举成员在定义时的顺序

示例：

public enum TestEnum {
    //枚举对象
    RED,BLACK,GREEN,WHITE;

    public static void main(String[] args) {
        //values() 以数组形式返回枚举类型的所有成员
        TestEnum[] testEnums = TestEnum.values();
        for (int i = 0; i < testEnums.length; i++) {
            System.out.println(testEnums[i]);
        }
        System.out.println("============");

        //ordinal() 获取枚举成员的索引位置
        for (int i = 0; i < testEnums.length; i++) {
            System.out.println(testEnums[i].ordinal());
        }
        System.out.println("============");

        //valueOf()  将普通字符串转换为枚举实例
        TestEnum val = TestEnum.valueOf("RED");
        //TestEnum val = TestEnum.valueOf("RED2");//error，该字符串必须在枚举对象中有对应的
        System.out.println(val);

        System.out.println("============");

        //compareTo() 比较两个枚举成员在定义时的顺序
        //因为枚举默认继承于Enum，Enum实现了Comparable接口，所以可以compareTo
        System.out.println(BLACK.compareTo(GREEN));
    }
}

运行结果：

查看Enum源码可以发现，该类只有一个构造方法，且是私有的，所以我们可以如下定义使用枚举：

public enum TestEnum {
    //枚举对象
    RED(1,"红色"),BLACK(2,"黑色"),
    GREEN(3,"绿色"),WHITE(4,"白色");

    public String color;
    public int ordinal;

    private TestEnum(int ordinal,String color) {
        this.color = color;
        this.ordinal = ordinal;
    }
}

3. 枚举优点缺点

优点：

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

缺点：

• 不可继承，无法扩展

4. 枚举与反射

枚举通过反射来拿实例化对象可行否？

在反射中，任何一个类，哪怕其构造方法是私有的，我们也可以通过反射拿到它的实例对象，下面用反射来拿枚举的实例对象：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Test {

    public static void main(String[] args) {
        Class<?> c1 = null;
        try {
            c1 = Class.forName("enumdemo.TestEnum");
            
            //这里传参不仅要传给自己重写的构造方法，还需要传参给父类的构造方法
            Constructor<?> constructor = c1.getDeclaredConstructor(String.class,int.class,int.class,String.class);

            constructor.setAccessible(true);

            TestEnum testEnum = (TestEnum)constructor.newInstance("haha",10,19,"白色");

            System.out.println(testEnum);

        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

运行结果：

我们查看报错的源码可以发现

 

 枚举在这里被过滤了，我们不能通过反射来获取枚举类的实例

该现象有关于面试题：为什么枚举实现单例模式是安全的

5. 面试问题

5.1 写一个单例模式

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

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

    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));
        }
    }

5.3 用枚举实现一个单例模式

    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));
        }
    }