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 的子类，也就是说，自己写的枚举类，就算没有显示的继承 Enum ，但是其默认继承了这个类。

使用

switch语句

/**
 * @author SongBiao
 * @Date 17:14
 */
public enum TestEnum {
    /*
    最终的输出结果为black
     */
    RED, BLACK, GREEN, WHITE;
    public static void main(String[] args) {
        TestEnum testEnum = TestEnum.BLACK;
        switch (testEnum) {
            case RED:
                System.out.println("red");
                break;
            case BLACK:
                System.out.println("black");
                break;
            case GREEN:
                System.out.println("black");
                break;
            default:
                break;
        }
    }
}

常用方法

Enum类的常用方法

示例1：values方法

/**
 * @author SongBiao
 * @Date 17:14
 */
public enum TestEnum {
    /*
    最终的输出结果为
    RED
    BLACK
    GREEN
    WHITE
     */
    RED, BLACK, GREEN, WHITE;
    public static void main(String[] args) {
        //将当前的枚举对象，封装为数组
        TestEnum[] testEnums = TestEnum.values();
        for (TestEnum testEnum : testEnums) {
            System.out.println(testEnum);
        }
    }
}

示例2：ordinal方法

/**
 * @author SongBiao
 * @Date 17:14
 */
public enum TestEnum {
    /*
    最终的输出结果为
    0 1 2 3
    即我们的枚举对象的下标
     */
    RED, BLACK, GREEN, WHITE;
    public static void main(String[] args) {
        //将当前的枚举对象，封装为数组
        TestEnum[] testEnums = TestEnum.values();
        for (int i = 0; i < testEnums.length; i++) {
            System.out.print(testEnums[i].ordinal()+" ");
        }
    }
}

示例3：valueOf方法

/**
 * @author SongBiao
 * @Date 17:14
 */
public enum TestEnum {
    /*
    最终的输出结果为
    GREEN
    假设为GREEN2的话，最终会报IllegalArgumentException异常:
     */
    RED, BLACK, GREEN, WHITE;
    public static void main(String[] args) {
        //根据字符串解析出来一个枚举对象
        System.out.println(TestEnum.valueOf("GREEN"));
    }
}

示例4:compareTo方法

/**
 * @author SongBiao
 * @Date 17:14
 */
public enum TestEnum {
    /*
    最终的输出结果为
    -1
     */
    RED, BLACK, GREEN, WHITE;
    public static void main(String[] args) {
        //点进源码的时候可以看到是二者ordinal的值作差
        //所以最终是RED的ordinal值减去BLACK的ordinal值为0-1=-1
        System.out.println(RED.compareTo(BLACK));
    }
}

刚刚说过，在Java当中枚举实际上就是一个类。所以我们在定义枚举的时候，还可以这样定义和使用枚举：

重要：枚举的构造方法默认是私有的

/**
 * @author SongBiao
 * @Date 17:14
 */
public enum TestEnum {
    /*
    这里的参数跟构造方法里面的参数类型和值是一样的
     */
    RED("red", 1), GREEN("green", 2), BLACK("black", 3);
    public String color;
    public int ordinal;
    //默认是私有的构造方法
    TestEnum(String color, int ordinal) {
        this.color = color;
        this.ordinal = ordinal;
    }
    public static TestEnum getEnumKey(int ordinal) {
        for (TestEnum t : TestEnum.values()) {
            if (t.ordinal == ordinal) {
                return t;
            }
        }
        return null;
    }
    public static void main(String[] args) {
        /*
        输出结果为GREEN
         */
        System.out.println(getEnumKey(2));
    }
}

枚举优点缺点

优点：

1.枚举常量更简单安全。

2.枚举具有内置方法，代码更优雅

缺点：

不可继承，无法扩展

枚举和反射

枚举是否可以通过反射，拿到实例对象呢？(面试考过)

我们刚刚在反射里边看到了，任何一个类，哪怕其构造方法是私有的，我们也可以通过反射拿到他的实例对象，那么枚举的构造方法也是私有的，我们是否可以拿到呢？接下来，我们来实验一下：

同样利用上述提供的枚举类来进行举例：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
 * @author SongBiao
 * @Date 17:14
 */
public enum TestEnum {
    /*
    这里的参数跟构造方法里面的参数类型和值是一样的
     */
    RED("red", 1), GREEN("green", 2), BLACK("black", 3);
    public String color;
    public int ordinal;
    //默认是私有的构造方法
    TestEnum(String color, int ordinal) {
        this.color = color;
        this.ordinal = ordinal;
    }
    public static TestEnum getEnumKey(int ordinal) {
        for (TestEnum t : TestEnum.values()) {
            if (t.ordinal == ordinal) {
                return t;
            }
        }
        return null;
    }
    public static void reflectPrivateConstructor() {
        try {
            Class<?> cl = Class.forName("TestEnum");
            //注意传入对应的参数,获得对应的构造方法来构造对象,当前枚举类是提供了两个参数分别是String和 int。
            Constructor<?> constructor =
                    cl.getDeclaredConstructor(String.class, int.class);
            //设置为true后可修改访问权限
            constructor.setAccessible(true);
            TestEnum yellow = (TestEnum) constructor.newInstance("黄色", 4);
            System.out.println("获得枚举的私有构造函数：" + yellow);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        reflectPrivateConstructor();
    }
}

输出结果:

什么意思是：就是没有对应的构造方法，我的天呐！我们提供的枚举的构造方法就是两个参数分别是String 和 int 啊！！！！问题出现在哪里呢？还记不记得我们说过的，我们所有的枚举类，都是默认继承与java.lang.Enum ,说到继承，继承了什么？继承了父类除构造函数外的所有东西，并且子类要帮助父类进行构造！我们在Enum类中可以看到这个类并没有无参的构造函数，只有有参的构造函数，之前我们说过：父类中没有定义无参的构造函数，而定义了有参的构造函数时，子类的构造函数(不管多少个)中都必须显示调用父类的有参构造函数而我们写的类，但是此时我们上述代码中的枚举类并没有帮助父类构造！那意思是，我们要在自己的枚举类里面，提供super吗？不是的，枚举比较特殊，虽然我们写的是两个，但是默认他还添加了两个参数，哪两个参数呢？我们看一下Enum类的源码：

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

也就是说，我们自己的构造函数有两个参数一个是String一个是int，同时他默认后边还会给两个参数，一个是

String一个是int。也就是说，这里我们正确给的是4个参数：

那么此时我们只需要修改reflectPrivateConstructor方法即可.

public static void reflectPrivateConstructor() {
        try {
            Class<?> cl = Class.forName("TestEnum");
            //注意此处我们修改对应的参数为4个
            Constructor<?> constructor =
                    cl.getDeclaredConstructor(String.class, int.class, String.class, int.class);
            //设置为true后可修改访问权限
            constructor.setAccessible(true);
            //注意这块前面传入的参数值是我们子类的，后面的参数值是我们父类的
            TestEnum yellow = (TestEnum) constructor.newInstance("黄色", 4, "父类的参数1", 110);
            System.out.println("获得枚举的私有构造函数：" + yellow);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

此时的运行结果是：

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

源码显示：

是的，枚举在这里被过滤了，你不能通过反射获取枚举类的实例！这道题是2017年阿里巴巴曾经问到的一个问题，不看不知道，一看吓一跳！同学们记住这个坑。原版问题是：为什么枚举实现单例模式是安全的？希望同学们记住这个问题！

总结

1、枚举本身就是一个类，其构造方法默认为私有的，且都是默认继承与java.lang.Enum

2、枚举可以避免反射和序列化问题

3、枚举的优点和缺点

面试问题(单例模式学完后可以回顾)

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

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

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

JAVA中的枚举

目录

枚举的使用

背景及定义

使用

switch语句

常用方法

枚举优点缺点

枚举和反射

枚举是否可以通过反射，拿到实例对象呢？(面试考过)

总结

面试问题(单例模式学完后可以回顾)

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

JAVA中的枚举

目录

枚举的使用

背景及定义

使用

switch语句

常用方法

枚举优点缺点

枚举和反射

枚举是否可以通过反射，拿到实例对象呢？(面试考过)

总结

面试问题(单例模式学完后可以回顾)

热门文章

最新文章

相关课程

相关电子书

相关实验场景