Java中定义受限数值类型：使用Enum的最佳实践

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

PlusOrMinusOne a = ...;
int b = a + 1; // 编译错误：无法直接对自定义对象进行算术运算
if (a == -1) // 编译错误：无法直接将自定义对象与整数进行比较

public enum SignValue { // 更好的命名，避免歧义
    PLUS_ONE(+1),
    MINUS_ONE(-1);

    private final int value; // 存储实际的整数值

    /**
     * 枚举的构造函数，用于初始化每个枚举常量关联的整数值。
     * 构造函数必须是私有的，以确保外部无法直接创建枚举实例。
     * @param value 关联的整数值
     */
    SignValue(int value) {
        this.value = value;
    }

    /**
     * 获取枚举常量所代表的实际整数值。
     * @return 关联的整数值
     */
    public int getValue() {
        return value;
    }

    /**
     * 静态工厂方法，根据给定的整数值返回对应的枚举常量。
     * 如果输入值不是+1或-1，则抛出IllegalArgumentException。
     * @param value 待转换的整数值
     * @return 对应的SignValue枚举常量
     * @throws IllegalArgumentException 如果值不是+1或-1
     */
    public static SignValue of(int value) {
        if (value == -1) {
            return MINUS_ONE;
        }
        if (value == +1) {
            return PLUS_ONE;
        }
        throw new IllegalArgumentException("Invalid value for SignValue: " + value);
    }

    /**
     * 返回当前枚举常量的相反值。
     * 例如，PLUS_ONE.neg() 返回 MINUS_ONE。
     * @return 相反的SignValue枚举常量
     */
    public SignValue neg() {
        if (this == PLUS_ONE) {
            return MINUS_ONE;
        }
        return PLUS_ONE; // 如果是MINUS_ONE，则返回PLUS_ONE
    }

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

public class SignValueDemo {
    public static void main(String[] args) {
        // 1. 直接使用枚举常量
        SignValue positive = SignValue.PLUS_ONE;
        SignValue negative = SignValue.MINUS_ONE;

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

        // 2. 获取实际的整数值
        int pValue = positive.getValue();
        int nValue = negative.getValue();
        System.out.println("Positive int value: " + pValue); // 输出: 1
        System.out.println("Negative int value: " + nValue); // 输出: -1

        // 3. 通过整数值获取枚举常量
        SignValue fromOne = SignValue.of(1);
        SignValue fromMinusOne = SignValue.of(-1);
        System.out.println("From 1: " + fromOne);       // 输出: +1
        System.out.println("From -1: " + fromMinusOne); // 输出: -1

        try {
            SignValue invalid = SignValue.of(0); // 抛出 IllegalArgumentException
        } catch (IllegalArgumentException e) {
            System.out.println("Error converting invalid value: " + e.getMessage());
        }

        // 4. 使用自定义逻辑方法
        SignValue oppositeOfPositive = positive.neg();
        SignValue oppositeOfNegative = negative.neg();
        System.out.println("Opposite of positive: " + oppositeOfPositive); // 输出: -1
        System.out.println("Opposite of negative: " + oppositeOfNegative); // 输出: +1

        // 5. 枚举的比较 (使用 ==)
        if (positive == SignValue.PLUS_ONE) {
            System.out.println("Positive is indeed PLUS_ONE.");
        }
        if (negative != positive) {
            System.out.println("Negative and Positive are different.");
        }
    }
}