Java运行时确定属性类变量类型并限制不可变更的实现咨询

首先，你的当前实现存在几个关键问题，导致它无法满足需求，甚至无法正常编译：

当前实现的核心问题 #

• 缺失必要成员变量：代码中用到的nameType和freeClassesType没有在类中定义，直接运行会报编译错误。
• 泛型擦除导致运行时类型失效：Java泛型是编译时特性，运行时A和B的类型信息会被擦除为Object，靠泛型约束运行时类型本质上走不通。
• 类型判断逻辑错误：getGenericSuperclass()获取的是父类类型，比如首次传入String，它的父类是Object，后续传入任何类型（比如Integer）的父类也是Object，等于没做任何类型校验。应该直接用getClass()获取实际类型。
• 扩展性极差：如果后续要新增age、percentage这类属性，你需要不断增加泛型参数（比如Attribute<A,B,C,D>），代码会变得极度臃肿。

方案1：修复当前类（适合属性固定的场景） #

如果你的属性列表（name、age、percentage、freeClasses）是固定不变的，可以先修正当前类的问题，让它能正常工作：

@Getter
public class Attribute {
    // 存储每个属性的类型
    private Class<?> nameType;
    private Class<?> ageType;
    private Class<?> percentageType;
    private Class<?> freeClassesType;

    // 属性值
    private Object name;
    private Object age;
    private Object percentage;
    private Object freeClasses;

    private Attribute() {}

    // 全参构造方法，支持部分属性初始化
    public Attribute(Object name, Object age, Object percentage, Object freeClasses) {
        if (name != null) setName(name);
        if (age != null) setAge(age);
        if (percentage != null) setPercentage(percentage);
        if (freeClasses != null) setFreeClasses(freeClasses);
    }

    public void setName(Object name) {
        checkAndSetType(name, "name", () -> nameType, type -> nameType = type, val -> this.name = val);
    }

    public void setAge(Object age) {
        checkAndSetType(age, "age", () -> ageType, type -> ageType = type, val -> this.age = val);
    }

    public void setPercentage(Object percentage) {
        checkAndSetType(percentage, "percentage", () -> percentageType, type -> percentageType = type, val -> this.percentage = val);
    }

    public void setFreeClasses(Object freeClasses) {
        checkAndSetType(freeClasses, "freeClasses", () -> freeClassesType, type -> freeClassesType = type, val -> this.freeClasses = val);
    }

    // 通用校验与赋值逻辑，避免重复代码
    private void checkAndSetType(Object value, String fieldName, Supplier<Class<?>> currentTypeGetter, Consumer<Class<?>> typeSetter, Consumer<Object> valueSetter) {
        Class<?> currentType = currentTypeGetter.get();
        Class<?> newValueType = value.getClass();

        // 首次赋值：记录类型
        if (currentType == null) {
            typeSetter.accept(newValueType);
            valueSetter.accept(value);
        } else {
            // 后续赋值：校验类型是否匹配
            if (!currentType.isAssignableFrom(newValueType)) {
                throw new InputMismatchException("Incorrect datatype provided for field: " + fieldName + 
                    ", expected " + currentType.getSimpleName() + ", got " + newValueType.getSimpleName());
            }
            valueSetter.accept(value);
        }
    }

    @SneakyThrows
    private void throwException(String attribute) {
        throw new InputMismatchException("Incorrect datatype provided for field: " + attribute);
    }
}

这个修复版本做了这些优化：

• 用Class<?>直接存储每个属性的类型，避免泛型擦除问题
• 提取通用的校验逻辑，减少重复代码
• 用isAssignableFrom做类型校验，支持子类类型（针对自定义类型场景）

方案2：通用属性存储方案（适合属性可能扩展的场景） #

如果你的属性可能后续新增，或者希望更灵活的存储方式，建议用全局属性类型注册表 + ID-属性映射的结构，完全适配你的所有需求：

1. 全局属性类型注册表（确保所有ID的同一属性类型一致） #

public class AttributeTypeRegistry {
    private static final Map<String, Class<?>> PROPERTY_TYPES = new ConcurrentHashMap<>();

    // 校验并注册属性类型（首次赋值时调用）
    public static void checkAndRegisterType(String propertyName, Object value) {
        Class<?> valueType = value.getClass();
        Class<?> existingType = PROPERTY_TYPES.get(propertyName);

        if (existingType == null) {
            PROPERTY_TYPES.put(propertyName, valueType);
        } else if (!existingType.isAssignableFrom(valueType)) {
            throw new InputMismatchException("Property '" + propertyName + "' requires type " + 
                existingType.getSimpleName() + ", got " + valueType.getSimpleName());
        }
    }

    // 获取属性的已注册类型
    public static Class<?> getPropertyType(String propertyName) {
        return PROPERTY_TYPES.get(propertyName);
    }
}

2. ID-属性存储类 #

public class AttributeStore {
    // 存储ID到属性值的映射：key=id，value=属性名-属性值的Map
    private final Map<Integer, Map<String, Object>> idToProperties = new ConcurrentHashMap<>();

    // 插入或更新单个属性
    public void setProperty(int id, String propertyName, Object value) {
        // 先校验类型（首次会自动注册）
        AttributeTypeRegistry.checkAndRegisterType(propertyName, value);
        
        // 获取该ID的属性Map，不存在则创建
        Map<String, Object> properties = idToProperties.computeIfAbsent(id, k -> new HashMap<>());
        properties.put(propertyName, value);
    }

    // 获取单个属性值
    public Object getProperty(int id, String propertyName) {
        Map<String, Object> properties = idToProperties.get(id);
        return properties != null ? properties.get(propertyName) : null;
    }

    // 获取某个ID的所有属性
    public Map<String, Object> getProperties(int id) {
        return idToProperties.getOrDefault(id, Collections.emptyMap());
    }
}

使用示例 #

public class Main {
    public static void main(String[] args) {
        AttributeStore store = new AttributeStore();

        // 首次设置id=1的freeClasses为boolean，自动注册类型
        store.setProperty(1, "freeClasses", true);

        // 正常设置id=2的freeClasses为boolean（符合已注册类型）
        store.setProperty(2, "freeClasses", false);

        // 尝试设置id=3的freeClasses为String，会抛出InputMismatchException
        try {
            store.setProperty(3, "freeClasses", "yes");
        } catch (InputMismatchException e) {
            System.out.println(e.getMessage()); // 输出：Property 'freeClasses' requires type Boolean, got String
        }
    }
}

这个方案的优势：

• 完全满足你的三个约束：运行时动态识别类型、首次赋值确定类型、后续类型不可变
• 扩展性极强，新增属性不需要修改代码，直接使用即可
• 线程安全（用ConcurrentHashMap），适合多线程场景
• 内存存储效率高，只存储实际用到的属性

关于Object类型的疑问 #

你担心用Object类型是否能满足第三个约束——答案是可以的，但必须配合类型元数据的存储与校验。Object只是存储值的容器，真正的类型约束需要靠额外的类型注册表（比如上面方案2中的AttributeTypeRegistry）来实现，每次赋值时校验值的类型是否与已注册的类型一致。

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