Java中如何创建值受限的自定义数据类型？

你说的这种只能取特定值的自定义类型，在面向对象编程里有非常成熟的实现方案，我分两种常见场景给你详细说明：

一、用枚举（Enum）实现（最推荐） #

枚举是专门为这种“有限可选值”的场景设计的，编译器会直接帮你限制变量的赋值范围，根本没法给它赋非法值。

示例1：交通灯状态 #

以你提到的trafficLight为例，用Java实现的话：

public enum TrafficLight {
    RED, AMBER, GREEN;
}

使用的时候，变量只能是这三个枚举实例中的一个：

// 合法赋值
TrafficLight currentLight = TrafficLight.RED;
// 下面这行代码会直接编译报错，因为不存在这个选项
// TrafficLight invalidLight = TrafficLight.BLUE;

示例2：硬币面额 #

如果你的类型需要附带额外属性（比如硬币的面额数值），枚举同样可以搞定：

public enum Coin {
    PENNY(0.01),
    TWO_PENCE(0.02),
    FIVE_PENCE(0.05),
    TEN_PENCE(0.1),
    TWENTY_PENCE(0.2),
    FIFTY_PENCE(0.5),
    ONE_POUND(1),
    TWO_POUND(2);

    // 存储硬币的面额数值
    private final double value;

    // 枚举的构造方法默认是私有的，外部无法调用
    Coin(double value) {
        this.value = value;
    }

    // 提供获取面额的方法
    public double getValue() {
        return value;
    }
}

使用时不仅能保证选项合法，还能拿到对应的数值：

Coin myCoin = Coin.FIVE_PENCE;
System.out.println(myCoin.getValue()); // 输出0.05

二、用封装类+私有构造实现（更灵活） #

如果你的场景比较复杂（比如需要动态加载可选值，或者某些语言没有枚举特性），可以用“封装类+私有构造+静态实例”的方式，手动限制实例的创建：

拿硬币面额举例，Java实现如下：

public class Coin {
    // 预先定义所有合法的硬币实例
    public static final Coin PENNY = new Coin(0.01);
    public static final Coin TWO_PENCE = new Coin(0.02);
    public static final Coin FIVE_PENCE = new Coin(0.05);
    // 其他面额依次定义...

    private final double value;

    // 把构造方法设为私有，外部无法直接new新的实例
    private Coin(double value) {
        this.value = value;
    }

    public double getValue() {
        return value;
    }

    // 可选：提供一个根据数值获取实例的方法，非法值直接抛出异常
    public static Coin fromValue(double value) {
        if (Double.compare(value, 0.01) == 0) {
            return PENNY;
        } else if (Double.compare(value, 0.02) == 0) {
            return TWO_PENCE;
        } else if (Double.compare(value, 0.05) == 0) {
            return FIVE_PENCE;
        }
        // 其他数值判断...
        else {
            throw new IllegalArgumentException("不支持的硬币面额：" + value);
        }
    }
}

这种方式下，外部只能使用类中预先定义好的静态实例，或者通过fromValue方法获取合法实例，完全杜绝了非法赋值的可能：

// 合法赋值
Coin validCoin = Coin.PENNY;
// 下面这行代码编译报错，因为构造方法是私有的
// Coin invalidCoin = new Coin(0.03);
// 传入非法值会抛出异常
Coin badCoin = Coin.fromValue(0.03); // 抛出IllegalArgumentException

其他语言的实现思路 #

比如在Python里，也可以用标准库的Enum类来实现：

from enum import Enum

class TrafficLight(Enum):
    RED = "red"
    AMBER = "amber"
    GREEN = "green"

class Coin(Enum):
    PENNY = 0.01
    TWO_PENCE = 0.02
    FIVE_PENCE = 0.05
    # 其他面额...

使用方式和Java类似，而且Python会自动限制枚举实例的唯一性。

总的来说，枚举是最直接高效的方案，能在编译/解释阶段就阻止非法赋值；封装类的方式则更灵活，适合复杂业务场景。

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