有可能在Java中创建泛型类型的实例吗?我在想，根据我所看到的，答案是否定的(由于类型擦除)，但如果有人能看到我遗漏的东西，我会很感兴趣:
class SomeContainer<E>
{
E createContents()
{
return what???
}
}
编辑:事实证明，超级类型令牌可以用来解决我的问题，但它需要大量基于反射的代码，如下面的一些答案所示。
我将把这个问题放一段时间，看看是否有人提出了与Ian Robertson的Artima文章截然不同的东西。
当前回答
package org.foo.com;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
/**
* Basically the same answer as noah's.
*/
public class Home<E>
{
@SuppressWarnings ("unchecked")
public Class<E> getTypeParameterClass()
{
Type type = getClass().getGenericSuperclass();
ParameterizedType paramType = (ParameterizedType) type;
return (Class<E>) paramType.getActualTypeArguments()[0];
}
private static class StringHome extends Home<String>
{
}
private static class StringBuilderHome extends Home<StringBuilder>
{
}
private static class StringBufferHome extends Home<StringBuffer>
{
}
/**
* This prints "String", "StringBuilder" and "StringBuffer"
*/
public static void main(String[] args) throws InstantiationException, IllegalAccessException
{
Object object0 = new StringHome().getTypeParameterClass().newInstance();
Object object1 = new StringBuilderHome().getTypeParameterClass().newInstance();
Object object2 = new StringBufferHome().getTypeParameterClass().newInstance();
System.out.println(object0.getClass().getSimpleName());
System.out.println(object1.getClass().getSimpleName());
System.out.println(object2.getClass().getSimpleName());
}
}
其他回答
正如你说的，你不能真正做到这一点，因为类型擦除。你可以使用反射来实现，但这需要大量的代码和错误处理。
如果你不想在实例化过程中键入类名两次，比如:
new SomeContainer<SomeType>(SomeType.class);
您可以使用工厂方法:
<E> SomeContainer<E> createContainer(Class<E> class);
就像:
public class Container<E> {
public static <E> Container<E> create(Class<E> c) {
return new Container<E>(c);
}
Class<E> c;
public Container(Class<E> c) {
super();
this.c = c;
}
public E createInstance()
throws InstantiationException,
IllegalAccessException {
return c.newInstance();
}
}
对诺亚的回答进行了改进。
改变的原因
a]如果使用多于一个泛型类型，则更安全，以防您更改顺序。
b]类泛型类型签名会不时变化，这样你就不会对运行时中无法解释的异常感到惊讶。
健壮的代码
public abstract class Clazz<P extends Params, M extends Model> {
protected M model;
protected void createModel() {
Type[] typeArguments = ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments();
for (Type type : typeArguments) {
if ((type instanceof Class) && (Model.class.isAssignableFrom((Class) type))) {
try {
model = ((Class<M>) type).newInstance();
} catch (InstantiationException | IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
}
或者使用一个眼线笔
一行代码
model = ((Class<M>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[1]).newInstance();
现在就可以这样做，而且不需要一堆反射代码。
import com.google.common.reflect.TypeToken;
public class Q26289147
{
public static void main(final String[] args) throws IllegalAccessException, InstantiationException
{
final StrawManParameterizedClass<String> smpc = new StrawManParameterizedClass<String>() {};
final String string = (String) smpc.type.getRawType().newInstance();
System.out.format("string = \"%s\"",string);
}
static abstract class StrawManParameterizedClass<T>
{
final TypeToken<T> type = new TypeToken<T>(getClass()) {};
}
}
当然，如果您需要调用需要一些反射的构造函数，但这是很好的文档，这个技巧不是!
下面是用于TypeToken的JavaDoc。
希望这还不算太晚!!
Java是类型安全的，这意味着只有对象才能创建实例。
在我的例子中，我不能将参数传递给createContents方法。我的解决方案是使用与下面的答案不同的扩展。
private static class SomeContainer<E extends Object> {
E e;
E createContents() throws Exception{
return (E) e.getClass().getDeclaredConstructor().newInstance();
}
}
这是我不能传递参数的例子。
public class SomeContainer<E extends Object> {
E object;
void resetObject throws Exception{
object = (E) object.getClass().getDeclaredConstructor().newInstance();
}
}
如果使用非对象类型扩展泛型类，则使用反射会产生运行时错误。将泛型类型扩展为对象，将此错误转换为编译时错误。
