Java -- 模板中Byte、Integer、Long等的原始对应物

Question

背景：

我正在尝试实现一个小模板，即通用 class，这将使我能够实现如下的按引用传递功能。

public static class Ref<T> {
    T value;
    public Ref(T InitValue)  { this.set(InitValue); }
    public void set(T Value) { this.value = Value; }
    public T    get()        { return this.value; }
}

所以，我可以定义一个带有 'Ref' 的函数，其中的值实际上可以更改，例如

public static void function(Ref<Byte> x)
{
    x.set((byte)0x7E);
}

要通过引用传递的变量的初始化看起来不太优雅。

Ref<Byte>  to_be_changed = new Ref<Byte>((byte)0);
...
function(to_be_changed); 
...
Byte       result = to_be_changed.get()

问题:

Java有没有更好的方法？构造函数是否可以根据与作为模板类型传递的包装类型相关的原始类型直接初始化为“0”？即类似

 ...
 public Ref() { this.value = (T.relatedPrimitiveClass())0; }
 ...

其中 Integer.relatedPrimitiveClass() 应交付 int； Byte.relatedPrimitiveClass() 交付 byte。

Answer 1

首先要理解的也是最重要的一点是 java 泛型不是模板。泛型是 classes/interfaces ，它们根据类型进行参数化。我推荐阅读 oracle 的泛型教程：https://docs.oracle.com/javase/tutorial/java/generics/types.html

可以使用反射来获取 Ref class 的参数化类型 T 并使用它来确定默认构造函数的初始值，但我不建议这样做。

您可以为需要默认构造函数的类型创建子classes，而不是反射（例如，基元的对象版本）：

public static class ByteRef extends Ref<Byte> {
    public ByteRef() {
        super((byte)0);
    }

    public ByteRef(byte value) {
        super(value);
    }

    // I'm not sure, if I like this one :-)
    public void set(int value) {
        super.set((byte)value);
    }
}

除了 subclassing，您还可以将新方法添加到 Ref class:

public static class Ref<T> {
    T value;

    public Ref(T initValue) {
        this.set(initValue);
    }

    public void set(T Value) {
        this.value = Value;
    }

    public T get() {
        return this.value;
    }

    public static Ref<Byte> createByteRef() {
        return new Ref<Byte>((byte)0);
    }

    public static Ref<Byte> createByteRef(byte value) {
        return new Ref<Byte>(value);
    }
}

或者您可以创建单独的工厂 classes： public class 引用 { public 静态参考 createByteRef() { return 新参考（（字节）0）； }

    public static Ref<Byte> createByteRef(byte value) {
        return new Ref<Byte>(value);
    }
}

最后一个选项是使用反射来获取参数化类型。我个人不会使用这个解决方案，因为原始 classes 的数量是有限的，你可以选择使用 subclassing

创建更整洁的界面

public abstract static class PrimitiveNumberRef<T extends Number> extends
        Ref<T> {
    private Class<T> type;

    public PrimitiveNumberRef() {
        // This requires default constructor for Ref class
        type = getGenericType(getClass());
        super.set((T) getInitialValue(type));
    }

    @Override
    public void set(T value) {
        if (value == null) {
            throw new IllegalArgumentException(
                    "Null value is not allowed for PrimitiveNumerRef type: "
                            + type);
        }
        if (!type.isInstance(value)) {
            throw new IllegalArgumentException("Unsupported value type: "
                    + value.getClass());
        }
        super.set(value);
    }

    @SuppressWarnings("unchecked")
    private static <T> Class<T> getGenericType(Class<?> clz) {
        return (Class<T>) ((ParameterizedType) clz.getGenericSuperclass())
                .getActualTypeArguments()[0];
    }

    private static <T> T getInitialValue(Class<T> clz) {
        if (clz == Byte.class) {
            return clz.cast((byte) 0);
        } else if (clz == Short.class) {
            return clz.cast((short) 0);
        } else if (clz == Integer.class) {
            return clz.cast((int) 0);
        } else if (clz == Double.class) {
            return clz.cast((double) 0);
        } else if (clz == Float.class) {
            return clz.cast((float) 0);
        } else if (clz == Long.class) {
            return clz.cast((long) 0);
        } else {
            throw new IllegalArgumentException("Unsupported type: "
                    + clz.getName());
        }
    }
}

PrimitiveNumberRef实例化如下：

Ref<Long> val1 = new PrimitiveNumberRef<Long>() { };

Java -- 模板中Byte、Integer、Long等的原始对应物

Java -- Primitive Counterpart of Byte, Integer, Long, etc. in template

java

primitive

integer

wrapper