应用场景

在某些情况下，一个类的对象的个数是有限的，
如季节，春夏秋冬，比如24节气，星期等等
规定这个类的对象的个数。

在以前的Calendar类中，把所有的方式以private static final定义了一遍
后面的变量值为int，显得很臃肿、麻烦，也会导致记不住
instance.get(Calendar.YEAR)与instance.get(1)效果一致

public class Ch01 {
    public static void main(String[] args) {
        Ch01 ch01 = new Ch01();
        Calendar instance = Calendar.getInstance();
        System.out.println(instance.get(Calendar.YEAR));
        System.out.println(instance.get(1));
    }
}

所以在JDK1.5迎来了大更新，更新了枚举类
在枚举类中：把需要用到的对象声明出来，写对应的构造器，也可以有set，get方法

SeansonEnum类

public enum SeasonEnum {

    SPRING(1,"春天"), // 第一个值为value，第二值为name
    SUMMER(2,"夏天"), // 在其他类直接使用SeasonEnum.SPIRING
    AUTUMN(3,"秋天"), // 即可获得数据
    WINNER(4,"冬天");
    
    private Integer value;
    private String name;

    SeasonEnum(Integer value, String name) {
        this.value = value;
        this.name = name;
    }

    public Integer getValue() {
        return value;
    }

    public void setValue(Integer value) {
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

枚举在switch中的使用

public class Ch03 {

    public static void main(String[] args) {
        SeasonEnum season = SeasonEnum.SPRING;

        switch (season) {
            case SPRING:
            case SUMMER:
            case AUTUMN:
            case WINNER:
        }
    }
}

枚举类的命名规则：所有的枚举类要以Enum结尾。

枚举的静态导入

import static com.domcer.java20220801.afternoon.SeasonEnum.SPRING;

public class Ch04 {

    public static void main(String[] args) {
        System.out.println(SPRING.getName());
    }
}

使用*号则代表导入枚举类的所有对象
import static com.domcer.java20220801.afternoon.SeasonEnum.*;

使用枚举类实现单例模式

高效Java，单元素的枚举类型已经成为实现单例模式的最佳方案。

class Singleton {
    // 私有化构造器 外部无法直接创建对象
    private Singleton() {}

    // 提供公有的获取实例的静态方法
    public static Singleton getInstance(){
        return SingletonHolder.INSTANT.instant;
    }

    // 声明一个枚举类（内部类）
    private enum SingletonHolder{
        // 枚举对象定义
        INSTANT;

        private final Singleton instant;

        SingletonHolder() {
            instant = new Singleton();
        }
    }
}

public class Ch05 {

    public static void main(String[] args) {
        System.out.println(Singleton.getInstance() == Singleton.getInstance());
    }
}

枚举的优势

1. int类型不具备安全性。假如某个程序员在定义int时少写了个final，会存在被他人修改的风险。枚举类，它天然就是一个常量类。
2. 使用int类型，语义不够明确。

使用枚举自定义异常信息

ResultMessage类

public enum ResultMessage {

    USERNAME_NOT_EXIST(101,"用户名不存在"),
    USERNAME_ALREADY_EXIST(102,"用户名已存在");

    private Integer code;
    private String message;

    ResultMessage(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

MyException类

public class MyException extends RuntimeException {

    private ResultMessage message;

    public MyException(ResultMessage message) {
        this.message = message;
    }

    public MyException(String message, ResultMessage message1) {
        super(message);
        this.message = message1;
    }

    public String getMessage() {

        return message.getMessage();
    }
}