Java 中如何使用枚举（Enum）定义固定常量集与自定义有限值类型

public class PlusOrMinusOne {
    private int plusOne = 1;
    private int minusOne = -1;
}

public enum PlusOrMinusOne {
    PLUS_ONE(+1), // 定义枚举常量 PLUS_ONE，关联值为 +1
    MINUS_ONE(-1); // 定义枚举常量 MINUS_ONE，关联值为 -1

    private final int value; // 用于存储每个枚举常量关联的整数值

    /**
     * 枚举的构造函数。
     * 枚举构造函数默认是私有的，不允许外部直接实例化。
     *
     * @param value 枚举常量关联的整数值
     */
    PlusOrMinusOne(int value) {
        this.value = value;
    }

    /**
     * 根据给定的整数值获取对应的 PlusOrMinusOne 枚举实例。
     *
     * @param value 整数值，期望为 -1 或 +1
     * @return 对应的 PlusOrMinusOne 枚举实例
     * @throws IllegalArgumentException 如果输入值不是 -1 或 +1
     */
    public static PlusOrMinusOne of(int value) {
        if (value == -1) {
            return MINUS_ONE;
        }
        if (value == +1) {
            return PLUS_ONE;
        }
        throw new IllegalArgumentException("Invalid value: " + value + ". Expected -1 or +1.");
    }

    /**
     * 获取当前枚举实例关联的整数值。
     *
     * @return 关联的整数值
     */
    public int getValue() {
        return value;
    }

    /**
     * 获取当前枚举实例的相反数。
     *
     * @return 如果当前是 PLUS_ONE，则返回 MINUS_ONE；否则返回 PLUS_ONE。
     */
    public PlusOrMinusOne neg() {
        if (this == PLUS_ONE) {
            return MINUS_ONE;
        }
        return PLUS_ONE;
    }

    /**
     * 重写 toString 方法，提供更友好的字符串表示。
     *
     * @return "+1" 或 "-1"
     */
    @Override
    public String toString() {
        return this == PLUS_ONE ? "+1" : "-1";
    }
}

public class EnumUsageDemo {
    public static void main(String[] args) {
        // 获取枚举实例
        PlusOrMinusOne positive = PlusOrMinusOne.PLUS_ONE;
        PlusOrMinusOne negative = PlusOrMinusOne.MINUS_ONE;

        System.out.println("Positive value: " + positive.getValue()); // 输出 1
        System.out.println("Negative value: " + negative.getValue()); // 输出 -1

        // 使用静态工厂方法根据整数值获取枚举实例
        PlusOrMinusOne fromInt1 = PlusOrMinusOne.of(1);
        PlusOrMinusOne fromIntMinus1 = PlusOrMinusOne.of(-1);
        System.out.println("From int 1: " + fromInt1); // 输出 +1 (通过toString())
        System.out.println("From int -1: " + fromIntMinus1); // 输出 -1 (通过toString())

        try {
            PlusOrMinusOne invalid = PlusOrMinusOne.of(0); // 尝试使用非法值，会抛出异常
        } catch (IllegalArgumentException e) {
            System.out.println("Error creating instance: " + e.getMessage());
        }

        // 使用自定义方法 neg()
        PlusOrMinusOne negatedPositive = positive.neg();
        System.out.println("Negated positive: " + negatedPositive); // 输出 -1

        // 比较枚举实例：直接使用 == 比较引用，因为枚举实例是单例的
        if (positive == PlusOrMinusOne.PLUS_ONE) {
            System.out.println("The positive instance is indeed PLUS_ONE.");
        }
    }
}