java - 执行时确定实例字段类型的通用参数

Question

情况说明:

我想实例化一个基本上有 2 个参数的对象。一组“元参数”和一个值。值的类型由“元参数”确定。

示例:

public class Meta
{

    public static final Meta META_FIRST = new Meta(String.class, new byte[] {0x00, 0x01});
    public static final Meta META_SECOND = new Meta(Float.class, new byte[] {0x00, 0x02});
    public static final Meta META_THIRD = new Meta(Double.class, new byte[] {0x00, 0x03});

    private Class<?> type;
    private byte[] prelude;

    private Meta(Class<?> type, byte[] prelude)
    {
        this.type = type;
        this.prelude = prelude;
    }

    public Class<?> getType()
    {
        return this.type;
    }

    public byte[] getPrelude()
    {
        return this.prelude;
    }
}

public class Record
{
    private # value;
    private byte[] prelude;

    public Record(Meta meta, # value)
    {
        this.prelude = meta.getPrelude();
    }

    public void doSomeWork()
    {
        //Do some work with prelude and value
    }
}

预期用途:

Record recordString = new Record(Meta.META_FIRST, "hello");
Record recordDouble = new Record(Meta.META_THIRD, 12.8);

我的疑问是如何确定“值”的类型(实际上是用“#”表示的)。 我认为泛型或反射可以解决我的问题，但我无法弄清楚构造函数中的参数如何影响另一个参数的类型。

我想在实例化记录时避免使用通用符号(这就是我将此“通用”信息放入元类中的原因)。

任何人都可以知道如何解决这个问题吗？ (随意建议其他方法)

注意:我也可以稍后用setter初始化记录值。

Answer 1

为了编译它，您必须使 Record 类通用(由值的类型参数化):

public class Record<T> {
    private T value;

    public Record(Meta meta, T value) {
        //Initialization
    }
}

但是，我不明白你有 Meta 类的原因，因为它除了保存 Class 的 value 类型之外什么也不做。为了简化层次结构并确保 Meta 与 value 类型兼容，我将删除 Meta 类并在 Class<T> 中保留 Record ，它将代表有关 value 的元。

public class Record<T> {
    private T value;
    private Class<T> meta;

    public Record(T value, Class<T> meta) {
        //Initialization
    }

    public Class<T> getMeta() {
        return meta;
    }
}

并将像这样使用它:

Record recordString = new Record("hello", String.class);
Class<String> recordStringMeta = recordString.getMeta();
Record recordDouble = new Record(12.8, Double.class);
Class<Double> recordDoubleMeta = recordDouble.getMeta();

<小时/>

更新:

由于您不想使用 Record 类泛型(我不建议您这样做，但是...)，您可以在那里引入三个构造函数，并将传递的 value 复制到Object 成员。不幸的是，这将迫使您在提取值时进行强制转换:

public class Record {
    private Object value;

    public Record(Meta meta, String value) {  ... }

    public Record(Meta meta, Double value) { ... }

    public Record(Meta meta, Float value) { ... }

}