Java中限制函数输入为特定整数的最佳实践是什么？

你提到的需求非常合理——比起在函数内部做判断，从调用层面就把非法输入挡在外面，能让代码更健壮、可读性更强，还能避免不必要的运行时错误。下面分享几种实用的方案，完全可以达到类似枚举的约束效果：

1. 用包装类封装合法整数（最接近枚举的体验） #

这是最推荐的方案，本质是把合法的整数值封装成一个不可变类，只对外暴露预定义的实例，就像枚举一样。调用方只能用你提供的实例，根本没法传入其他整数。

示例代码：

import java.util.Objects;

public class ValidInteger {
    // 预定义所有合法值
    public static final ValidInteger VALUE_1 = new ValidInteger(1);
    public static final ValidInteger VALUE_5 = new ValidInteger(5);
    public static final ValidInteger VALUE_10 = new ValidInteger(10);

    private final int value;

    // 私有构造方法，禁止外部随意实例化
    private ValidInteger(int value) {
        this.value = value;
    }

    // 提供获取原始整数值的方法
    public int getValue() {
        return value;
    }

    // 可选：重写equals和hashCode，方便比较操作
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ValidInteger that = (ValidInteger) o;
        return value == that.value;
    }

    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
}

你的业务函数可以这样定义：

public void processValidInput(ValidInteger input) {
    int rawValue = input.getValue();
    // 直接处理逻辑，完全不用担心非法值
}

调用时只能用预定义的实例：

processValidInput(ValidInteger.VALUE_5); // 合法调用
// processValidInput(new ValidInteger(3)); // 编译报错，构造方法是私有的

优点：完全在编译期限制输入，调用方没有机会传入非法值；和枚举一样直观，还能保留整数的原始用途。
缺点：需要额外编写一个类，但代码模板固定，维护成本极低。

2. 使用枚举关联整数值 #

其实枚举并不是不能和整数配合——你可以给枚举常量绑定对应的整数值，调用方传入枚举，函数内部再取出对应的整数。这也是Java中很常用的方式。

示例代码：

public enum ValidNumber {
    ONE(1),
    FIVE(5),
    TEN(10);

    private final int value;

    ValidNumber(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    // 可选：添加从整数转枚举的方法，方便处理外部传入的原始值
    public static ValidNumber fromValue(int value) {
        for (ValidNumber num : ValidNumber.values()) {
            if (num.value == value) {
                return num;
            }
        }
        throw new IllegalArgumentException("Invalid value: " + value);
    }
}

函数定义：

public void processNumber(ValidNumber input) {
    int rawValue = input.getValue();
    // 处理逻辑
}

调用：

processNumber(ValidNumber.FIVE); // 合法调用
// processNumber(ValidNumber.fromValue(7)); // 运行时抛出异常，但编译期能明确可选值范围

优点：枚举是Java原生特性，代码简洁；自带valueOf、values等方法，方便遍历和序列化。
缺点：如果需要频繁把原始整数转成枚举，需要额外处理不存在的情况，但这比函数内部做一堆if判断要优雅得多。

3. 使用Sealed Class（Java 17+） #

如果你的项目用的是Java 17及以上版本，密封类是个更灵活的选择——它可以限制子类的范围，同时允许你定义不同类型的合法值（比如不仅限于整数，还能扩展其他类型）。

示例代码：

public sealed class RestrictedInt permits RestrictedInt.One, RestrictedInt.Five, RestrictedInt.Ten {
    public abstract int getValue();

    public static final class One extends RestrictedInt {
        @Override
        public int getValue() {
            return 1;
        }
    }

    public static final class Five extends RestrictedInt {
        @Override
        public int getValue() {
            return 5;
        }
    }

    public static final class Ten extends RestrictedInt {
        @Override
        public int getValue() {
            return 10;
        }
    }
}

函数定义：

public void processRestrictedInput(RestrictedInt input) {
    int value = input.getValue();
    // 处理逻辑
}

调用：

processRestrictedInput(new RestrictedInt.Five()); // 合法调用
// processRestrictedInput(new RestrictedInt() {}); // 编译报错，密封类不允许其他子类

优点：比包装类更灵活，适合需要扩展不同类型合法值的场景；编译期安全。
缺点：代码量稍大，且依赖Java 17+的特性。

为什么不推荐内部if判断？ #

你提到不想用内部if判断，这点非常明智——这种方式把错误检查推迟到运行时，调用方可能直到上线才发现传错了值；而且函数签名无法体现合法输入的范围，可读性差，维护时也容易漏判某个值。

总结一下，最推荐的是包装类封装或者枚举关联整数值，这两种都能在编译期就限制输入，完全符合你想要的“像枚举那样从调用层面限制”的需求。

内容的提问来源于stack exchange，提问作者KaO