有可能在Java中创建泛型类型的实例吗?我在想，根据我所看到的，答案是否定的(由于类型擦除)，但如果有人能看到我遗漏的东西，我会很感兴趣:
class SomeContainer<E>
{
E createContents()
{
return what???
}
}
编辑:事实证明，超级类型令牌可以用来解决我的问题，但它需要大量基于反射的代码，如下面的一些答案所示。
我将把这个问题放一段时间，看看是否有人提出了与Ian Robertson的Artima文章截然不同的东西。
当前回答
如果你的意思是 新的E () 那就不可能了。我想补充一点，它并不总是正确的——你怎么知道E是否有公共的无参数构造函数? 但是你总是可以把创建委托给其他知道如何创建实例的类——它可以是class <E>或你的自定义代码，就像这样
interface Factory<E>{
E create();
}
class IntegerFactory implements Factory<Integer>{
private static int i = 0;
Integer create() {
return i++;
}
}
其他回答
如果你的意思是 新的E () 那就不可能了。我想补充一点，它并不总是正确的——你怎么知道E是否有公共的无参数构造函数? 但是你总是可以把创建委托给其他知道如何创建实例的类——它可以是class <E>或你的自定义代码，就像这样
interface Factory<E>{
E create();
}
class IntegerFactory implements Factory<Integer>{
private static int i = 0;
Integer create() {
return i++;
}
}
我不知道这是否有帮助，但当您子类化(包括匿名)泛型类型时，类型信息可以通过反射获得。例如,
public abstract class Foo<E> {
public E instance;
public Foo() throws Exception {
instance = ((Class)((ParameterizedType)this.getClass().
getGenericSuperclass()).getActualTypeArguments()[0]).newInstance();
...
}
}
所以，当你子类化Foo时，你得到Bar的一个实例，例如，
// notice that this in anonymous subclass of Foo
assert( new Foo<Bar>() {}.instance instanceof Bar );
但是工作量很大，而且只适用于子类。不过也很方便。
现在就可以这样做，而且不需要一堆反射代码。
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。
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());
}
}
注意，kotlin中的泛型类型可能没有默认构造函数。
implementation("org.objenesis","objenesis", "3.2")
val fooType = Foo::class.java
var instance: T = try {
fooType.newInstance()
} catch (e: InstantiationException) {
// Use Objenesis because the fooType class has not a default constructor
val objenesis: Objenesis = ObjenesisStd()
objenesis.newInstance(fooType)
}
没有默认构造函数 Objenesis
