【Java】基础入门（十八）--- 枚举

1> 枚举

在 Java 中，枚举（Enum）是一种特殊的数据类型，用于定义一组命名的常量。枚举常用于表示一组相关的常量，并且可以增加额外的属性和方法。
在 Java 中，枚举是一种类，可以定义成员变量和方法。

示例1

/**
 * 枚举类型，隐式默认继承 java.long Enum
 */
public enum Day{
    // 定义枚举常量
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
}

public class UsagesDay {
    public static void main(String[] args) {
        // 使用枚举常量
        Day today = Day.FRIDAY;

        // 访问枚举常量的值
        System.out.println("Today is " + today);

        // 使用 switch 语句处理枚举
        switch (today) {
            case FRIDAY -> System.out.println(today.name());
            case MONDAY -> System.out.println("这是周一");
            case SUNDAY -> System.out.println("周末到了，要不要休息一天呢？");
            default -> System.out.println("这是其他");
        }
    }
}

除了继承 Enum 类之外，枚举类型还可以实现接口，并重写接口中的方法。这使得枚举类型能够拥有自己的行为和特性。枚举的常量必须写在第一行，并且这些常量的类型为枚举名（如上述类型为 Day）

需要注意的是，在 Java 中，由于类只能单继承，所以枚举类型不能再继承其他类( 隐式 final 修饰 )，但是可以实现多个接口。

枚举可以像其他类一样拥有构造函数（不能实例化）、成员变量和成员方法，不能被继承。

示例2

public enum Day{
    // 定义枚举常量
    SUNDAY("星期日"), MONDAY("星期一"), TUESDAY("星期二"), WEDNESDAY("星期三"),
    THURSDAY("星期四"), FRIDAY("星期五"), SATURDAY("星期六");

    private final String shortName;

    // 构造函数
    Day(String shortName) {
        this.shortName = shortName;
    }

    // 获取枚举常量的简称
    public String getShortName() {
        return shortName;
    }
}

public class UsagesDay {
    public static void main(String[] args) {
        // 使用枚举常量
        Day today = Day.FRIDAY;

        // 访问枚举常量的值
        System.out.println("Today is " + today.getShortName());
    }
}

在实际开发在中，枚举常用于管理固定的常量集合，例如星期、月份、状态等。使用枚举可以是代码更具可读性和可维护性。

枚举常用的方法

1. value()

values() 方法返回一个包含枚举类型所有枚举常量的数组。该方法允许我们遍历枚举中的所有的值。

import java.util.Arrays;

public class EnumValues {
    enum Day{
        星期一, 星期二, 星期三, 星期四, 星期五, 星期六, 星期日;
    }

    public static void main(String[] args) {
        Day[] days = Day.values();
        System.out.println(Arrays.toString(days));  // [星期一, 星期二, 星期三, 星期四, 星期五, 星期六, 星期日]
    }
}

2. ordinal()

ordinal() 方法返回一个枚举常量在枚举类型中的索引位置（从0开始）。注意，ordinal() 方法在某些情况下可能不是一样高很好的选择，因为它依赖于枚举常量的声明顺序，而这个顺序可能会在代码维护过程中发生变化。

public class EnumOrdinal {
    enum Day{
        星期一, 星期二, 星期三, 星期四, 星期五, 星期六, 星期日;
    }

    public static void main(String[] args) {
        Day day = Day.星期三;
        int position = day.ordinal();
        System.out.println(position);  // 2
    }
}

3. valueOf()

valueOf() 方法允许通过枚举常量的名称来获取对应的枚举类型实例。它将一个字符串转换成对应的枚举常量。

public class EnumValueOf {
    enum Color {
        RED, GREEN, BLUE;
    }

    public static void main(String[] args) {
        String colorName = "GREEN";
        Color myColor = Color.valueOf(colorName);
        System.out.println("我选择的眼神是" + myColor);
    }
}

2> 单例模式

单例模式是一种设计模式，它保证一个类只能实例化一个对象，并提供一个全局访问点。

1. 枚举（Enum）

public enum Singleton {
    INSTANCE;

    // 可选：添加其他类成员和方法

    public void doSomething() {
        // 单例对象的方法
    }
}

2. 饿汉式（Eager Initialization）

public class EagerSingleton {
    // 单例模式：饿汉式
    private static final EagerSingleton instance = new EagerSingleton();

    private EagerSingleton() {
        // 私有构造函数
    }

    public static EagerSingleton getInstance() {
        return instance;
    }
}

class Main {
    public static void main(String[] args) {
        EagerSingleton eager1 = EagerSingleton.getInstance();
        EagerSingleton eager2 = EagerSingleton.getInstance();
        System.out.println(eager2 == eager1);  // true
    }
}

3. 懒汉式（Lazy Initialization）

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // 私有构造函数
    }

    public static LazySingleton getInstance() {
        if (instance == null) {
            synchronized (LazySingleton.class) {
                if (instance == null) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

class Main1 {
    public static void main(String[] args) {
        LazySingleton lazySingleton1 = LazySingleton.getInstance();
        LazySingleton lazySingleton = LazySingleton.getInstance();
        System.out.println(lazySingleton == lazySingleton1);  // true
    }
}

4. 静态嵌套类

public class StaticSingleton {
    private StaticSingleton() {
        // 私有构造函数
        if (StaticSingleton.getInstance() != null) {
            throw new RuntimeException("已实例化");
        }
    }

    private static class SingletonHolder {
        private static final StaticSingleton INSTANCE = new StaticSingleton();
    }

    public static StaticSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

class Main2 {
    public static void main(String[] args) {
        StaticSingleton singleton = StaticSingleton.getInstance();
        StaticSingleton singleton1 = StaticSingleton.getInstance();
        System.out.println(singleton1 == singleton);  // true
    }
}