如何在 Java 中实例化泛型类型？

Question

我已经使用java.util.Properties 向我的应用程序添加了一个人类可读的配置文件，并尝试在它周围添加一个包装器以使类型转换更容易。具体来说，我希望返回的值从提供的默认值“继承”它的类型。到目前为止，这是我所得到的：

protected <T> T getProperty(String key, T fallback) {
    String value = properties.getProperty(key);

    if (value == null) {
        return fallback;
    } else {
        return new T(value);
    }
}

(Full example source.)

getProperty("foo", true) 的返回值将是一个布尔值，无论它是否是从属性文件中读取的，对于字符串、整数、双精度数等也是如此。当然，上面的 sn -p 并没有真正编译：

PropertiesExample.java:35: unexpected type
found   : type parameter T
required: class
                        return new T(value);
                                   ^
1 error

是我做错了，还是我只是想做一些不能做的事情？

编辑：用法示例：

// I'm trying to simplify this...
protected void func1() {
    foobar = new Integer(properties.getProperty("foobar", "210"));
    foobaz = new Boolean(properties.getProperty("foobaz", "true"));
}

// ...into this...
protected void func2() {
    foobar = getProperty("foobar", 210);
    foobaz = getProperty("foobaz", true);
}

Answer 1

由于type erasure，您无法实例化通用对象。通常，您可以保留对代表该类型的Class 对象的引用，并使用它来调用newInstance()。但是，这仅适用于默认构造函数。由于您想使用带参数的构造函数，因此您需要查找 Constructor 对象并将其用于实例化：

protected <T> T getProperty(String key, T fallback, Class<T> clazz) {
    String value = properties.getProperty(key);

    if (value == null) {
        return fallback;
    } else {

        //try getting Constructor
        Constructor<T> constructor;
        try {
            constructor = clazz.getConstructor(new Class<?>[] { String.class });
        }
        catch (NoSuchMethodException nsme) {
            //handle constructor not being found
        }

        //try instantiating and returning
        try {
            return constructor.newInstance(value);
        }
        catch (InstantiationException ie) {
            //handle InstantiationException
        }
        catch (IllegalAccessException iae) {
            //handle IllegalAccessException
        }
        catch (InvocationTargetException ite) {
            //handle InvocationTargetException
        }
    }
}

但是，看到实现这一点有多麻烦，包括使用反射的性能成本，值得首先研究其他方法。

如果您绝对需要采用这条路线，并且如果 T 仅限于编译时已知的一组不同类型，则折衷方案是保留 Constructors 的静态 Map，它已加载在启动时 - 这样您就不必在每次调用此方法时动态查找它们。例如 Map<String, Constructor<?>> 或 Map<Class<?>, Constructor<?>>，使用 static block 填充。

Answer 2

这是你做不到的。

由于类型擦除，T 类型虽然在编译时已知，但在运行时对 JVM 不可用。

对于你的具体问题，我认为最合理的解决方案是手动为每种不同类型编写代码：

protected String getProperty(String key, String fallback) { ... return new String(value); }
protected Double getProperty(String key, Double fallback) { ... return new Double(value); }
protected Boolean getProperty(String key, Boolean fallback) { ... return new Boolean(value); }
protected Integer getProperty(String key, Integer fallback) { ... return new Integer(value); }

注意事项：

• 在 Java 标准 API 中，您会发现很多地方都有一组相关方法，它们只是输入类型不同。
• 在 C++ 中，您可能可以通过 模板 解决。但是 C++ 引入了许多其他问题......

Answer 3

泛型是在 Java 中使用类型擦除实现的。用英文术语来说，大多数通用信息在编译时都会丢失，在运行时你无法知道T 的实际值。这意味着您根本无法实例化泛型类型。

另一种解决方案是在运行时为您的类提供类型：

class Test<T> {

    Class<T> klass;

    Test(Class<T> klass) {
        this.klass = klass;
    }

    public void test() {
        klass.newInstance(); // With proper error handling
    }

}

编辑：更接近您的案例的新示例

static <T> T getProperty(String key, T fallback, Class<T> klass) {
    // ...

    if (value == null) {
        return fallback;
    }
    return (T) klass.newInstance(); // With proper error handling
}

Answer 4

如果您想保留现有的方法签名，请这样做。

import java.lang.reflect.InvocationTargetException;
import java.util.Properties;

public class Main
{
    private final Properties properties;

    public Main()
    {
        this.properties  = new Properties();
        this.properties.setProperty("int", "1");
        this.properties.setProperty("double", "1.1");
    }

    public <T> T getProperty(final String key, final T fallback)
    {
        final String value = this.properties.getProperty(key);
        if (value == null)
        {
            return fallback;
        }
        else
        {
            try
            {
                return (T) fallback.getClass().getConstructor(new Class<?>[] { String.class } ).newInstance(value);
            }
            catch (final InstantiationException e)
            {
                throw new RuntimeException(e);
            }
            catch (final IllegalAccessException e)
            {
                throw new RuntimeException(e);
            }
            catch (final InvocationTargetException e)
            {
                throw new RuntimeException(e);
            }
            catch (final NoSuchMethodException e)
            {
                throw new RuntimeException(e);
            }
        }
    }


    public static void main(final String[] args)
    {
        final Main m = new Main();
        final Integer i = m.getProperty("int", new Integer("0"));
        final Double d = m.getProperty("double", new Double("0"));
        System.out.println(i);
        System.out.println(d);
    }
}

Answer 5

以下使用functional interfaces。

您可以更改方法签名以使用提供的“解析器”：

protected <T> T getProperty(String key, T fallback, Function<String, ? extends T> parser) {
    String value = properties.getProperty(key);

    if (value == null) {
        return fallback;
    } else {
        return parser.apply(value);
    }
}

此外，为了提高效率，您可能希望将 T fallback 替换为 Supplier<? extends T> fallbackSupplier 以防止在不需要时创建备用值：

protected <T> T getProperty(String key, Supplier<? extends T> fallbackSupplier, Function<String, ? extends T> parser) {
    String value = properties.getProperty(key);

    if (value == null) {
        return fallbackSupplier.get();
    } else {
        return parser.apply(value);
    }
}

然后您可以使用method references 和lambda expressions 作为解析器和后备供应商，例如：

protected void func2() {
    foobar = getProperty("foobar", () -> 210, Integer::valueOf);
    // Better create own parsing method which properly handles 
    // invalid boolean strings instead of using Boolean#valueOf
    foobaz = getProperty("foobaz", () -> true, Boolean::valueOf);

    // Imagine creation of `ExpensiveObject` is time-wise or 
    // computational expensive
    bar = getProperty("bar", ExpensiveObject::new, ExpensiveObject::parse);
}

---

这种方法的优点是它不再局限于（可能不存在的）构造函数。

Answer 6

试试这个：

protected <T> T getProperty(String key, T fallback) {
    String value = properties.getProperty(key);

    if (value == null) {
        return fallback;
    } else {
        Class FallbackType = fallback.getClass();
        return (T)FallbackType.cast(value);
    }
}