是否可以在Java中创建泛型类型的实例？我正在考虑基于我所看到的答案是no（由于类型擦除），但是如果有人能看到我缺少的东西，我会感兴趣：
class SomeContainer<E>
{
E createContents()
{
return what???
}
}
编辑：事实证明Super Type Tokens可用于解决我的问题，但它需要大量基于反射的代码，正如下面的一些答案所示。
如果有人提出与Ian Robertson的Artima Article截然不同的任何东西，我会暂时搁置一下。
答案 0 :(得分：310)
你是对的。你做不到new E()。但你可以把它改成
private static class SomeContainer<E> {
E createContents(Class<E> clazz) {
return clazz.newInstance();
}
}
这是一种痛苦。但它的确有效。将其包装在工厂模式中使其更容易忍受。
答案 1 :(得分：122)
Dunno如果这有帮助，但是当您将（通过匿名）子类化为泛型类型时，类型信息可通过反射获得。如，
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 );
但这是很多工作，只适用于子类。虽然可以很方便。
答案 2 :(得分：94)
在Java 8中，您可以使用defined功能界面轻松实现此目的：
String::new你可以这样构建这个类：
SomeContainer<BigInteger> bigIntegerContainer
= new SomeContainer<>(() -> new BigInteger(1));
该行的语法from tkinter import *
为Supplier。
如果构造函数接受参数，则可以使用lambda表达式：
def nameFunc():
messagebox.showinfo(........)
答案 3 :(得分：87)
你需要某种类型的抽象工厂来推卸责任：
interface Factory<E> {
E create();
}
class SomeContainer<E> {
private final Factory<E> factory;
SomeContainer(Factory<E> factory) {
this.factory = factory;
}
E createContents() {
return factory.create();
}
}
答案 4 :(得分：23)
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());
}
}
答案 5 :(得分：18)
您现在可以执行此操作，并且不需要一堆反射代码。
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()) {};
}
}
当然，如果你需要调用需要反思的构造函数，但是这个文档记录得非常好，这个技巧不是！
答案 6 :(得分：12)
考虑一种更具功能性的方法：不要创造一些无中生有的东西（这显然是代码气味），而是传递一个知道如何创建一个的函数，即
E createContents(Callable<E> makeone) {
return makeone.call(); // most simple case clearly not that useful
}
答案 7 :(得分：8)
来自Java Tutorial - Restrictions on Generics：
<强> Cannot Create Instances of Type Parameters
您无法创建类型参数的实例。例如，以下代码导致编译时错误：
public static <E> void append(List<E> list) {
E elem = new E(); // compile-time error
list.add(elem);
}
作为一种变通方法，您可以通过反射创建一个类型参数的对象：
public static <E> void append(List<E> list, Class<E> cls) throws Exception {
E elem = cls.newInstance(); // OK
list.add(elem);
}
您可以按如下方式调用append方法：
List<String> ls = new ArrayList<>();
append(ls, String.class);
答案 8 :(得分：6)
这是我想出的一个选项，它可能会有所帮助：
public static class Container<E> {
private Class<E> clazz;
public Container(Class<E> clazz) {
this.clazz = clazz;
}
public E createContents() throws Exception {
return clazz.newInstance();
}
}
编辑：或者您可以使用此构造函数（但它需要E的实例）：
@SuppressWarnings("unchecked")
public Container(E instance) {
this.clazz = (Class<E>) instance.getClass();
}
答案 9 :(得分：6)
如果您不希望在实例化期间两次输入类名，如：
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();
}
}
答案 10 :(得分：5)
Java不幸地不允许你想做什么。请参阅official workaround：
您无法创建类型参数的实例。例如，以下代码导致编译时错误：
public static <E> void append(List<E> list) {
E elem = new E(); // compile-time error
list.add(elem);
}
作为一种变通方法，您可以通过反射创建一个类型参数的对象：
public static <E> void append(List<E> list, Class<E> cls) throws Exception {
E elem = cls.newInstance(); // OK
list.add(elem);
}
您可以按如下方式调用append方法：
List<String> ls = new ArrayList<>();
append(ls, String.class);
答案 11 :(得分：4)
当您在编译时使用E时，您并不关心实际的泛型类型“E”（要么使用反射，要么使用泛型类型的基类），所以让子类提供E的实例。
Abstract class SomeContainer<E>
{
abstract protected E createContents();
public doWork(){
E obj = createContents();
// Do the work with E
}
}
**BlackContainer extends** SomeContainer<Black>{
Black createContents() {
return new Black();
}
}
答案 12 :(得分：3)
您可以使用：
Class.forName(String).getConstructor(arguments types).newInstance(arguments)
但是你需要提供确切的类名，包括包，例如。 java.io.FileInputStream。我用它来创建一个数学表达式解析器。
答案 13 :(得分：2)
我认为我可以做到这一点，但很失望：它不起作用，但我认为值得分享。
也许有人可以纠正：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface SomeContainer<E> {
E createContents();
}
public class Main {
@SuppressWarnings("unchecked")
public static <E> SomeContainer<E> createSomeContainer() {
return (SomeContainer<E>) Proxy.newProxyInstance(Main.class.getClassLoader(),
new Class[]{ SomeContainer.class }, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Class<?> returnType = method.getReturnType();
return returnType.newInstance();
}
});
}
public static void main(String[] args) {
SomeContainer<String> container = createSomeContainer();
[*] System.out.println("String created: [" +container.createContents()+"]");
}
}
它产生：
Exception in thread "main" java.lang.ClassCastException: java.lang.Object cannot be cast to java.lang.String
at Main.main(Main.java:26)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:601)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:120)
第26行是[*]。
唯一可行的解决方案是@JustinRudd
答案 14 :(得分：2)
@ Noah的回答是一种改变。
变更原因
a] 如果您更改了订单，则使用超过1种通用类型会更安全。
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();
答案 15 :(得分：0)
正如你所说，由于类型擦除，你无法真正做到这一点。您可以使用反射进行排序，但它需要大量代码和大量错误处理。
答案 16 :(得分：0)
有各种库可以使用类似于Robertson文章讨论的技术为您解决E。这是createContents的实现，它使用TypeTools来解析由E表示的原始类：
E createContents() throws Exception {
return TypeTools.resolveRawArgument(SomeContainer.class, getClass()).newInstance();
}
这假设getClass（）解析为SomeContainer的子类，否则将失败，因为如果没有在子类中捕获，E的实际参数化值将在运行时被擦除。
答案 17 :(得分：0)
您可以使用以下代码段实现此目的：
import java.lang.reflect.ParameterizedType;
public class SomeContainer<E> {
E createContents() throws InstantiationException, IllegalAccessException {
ParameterizedType genericSuperclass = (ParameterizedType)
getClass().getGenericSuperclass();
@SuppressWarnings("unchecked")
Class<E> clazz = (Class<E>)
genericSuperclass.getActualTypeArguments()[0];
return clazz.newInstance();
}
public static void main( String[] args ) throws Throwable {
SomeContainer< Long > scl = new SomeContainer<>();
Long l = scl.createContents();
System.out.println( l );
}
}
答案 18 :(得分：0)
以下是使用TypeTools来解析createContents所代表的原始类的E的实现：
E createContents() throws Exception {
return TypeTools.resolveRawArgument(SomeContainer.class, getClass()).newInstance();
}
此方法仅在SomeContainer被子类化时才有效，因此在类型定义中捕获E的实际值：
class SomeStringContainer extends SomeContainer<String>
否则E的值在运行时被删除，无法恢复。
答案 19 :(得分：0)
return (E)((Class)((ParameterizedType)this.getClass().getGenericSuperclass()).getActualTypeArguments()[0]).newInstance();
答案 20 :(得分：0)
如果你的意思
new E()
那是不可能的。我想补充一点，它并不总是正确的 - 你怎么知道E是否有公共的无参数构造函数？
但您总是可以将创建委托给知道如何创建实例的其他类 - 它可以是Class<E>或您的自定义代码
interface Factory<E>{
E create();
}
class IntegerFactory implements Factory<Integer>{
private static int i = 0;
Integer create() {
return i++;
}
}
答案 21 :(得分：0)
希望这还为时不晚！
Java是类型安全的，只有Object才能创建实例。
就我而言，我无法将参数传递给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();
}
}
如果您将通用类扩展为没有对象类型，则使用反射创建运行时错误。要将泛型类型扩展为对象，请将此错误转换为编译时错误。
答案 22 :(得分：0)
你能做的是-
首先声明该通用类的变量
2。然后构造它并实例化该对象
然后在您想使用它的任何地方使用它
示例-
1
private Class<E> entity;
2
public E getEntity(Class<E> entity) throws InstantiationException, IllegalAccessException {
return entity.newInstance();
}
3
E e = getEntity(entity);
答案 23 :(得分：0)
使用TypeToken<T>类：
func insertEntries(){
if itemsToInsert.count == 0{
return
}
let entry = itemsToInsert.first
itemsToInsert.removeFirst()
let indexPath = IndexPath(row: 0, section: 0)
tableView.beginUpdates()
dataArray.insert(entry!, at: 0)
tableView.insertRows(at: [indexPath], with: UITableView.RowAnimation.bottom)
tableView.endUpdates()
insertEntries()
}
答案 24 :(得分：0)
请注意，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)
}
答案 25 :(得分：0)
我受到了 Ira 解决方案的启发并对其进行了略微修改。
abstract class SomeContainer<E>
{
protected E createContents() {
throw new NotImplementedException();
}
public void doWork(){
E obj = createContents();
// Do the work with E
}
}
class BlackContainer extends SomeContainer<Black>{
// this method is optional to implement in case you need it
protected Black createContents() {
return new Black();
}
}
如果你需要 E 实例，你可以在你的派生类中实现 createContents 方法（或者不实现它，以防你不需要它。
答案 26 :(得分：-1)
您可以使用类加载器和类名，最终使用一些参数。
final ClassLoader classLoader = ...
final Class<?> aClass = classLoader.loadClass("java.lang.Integer");
final Constructor<?> constructor = aClass.getConstructor(int.class);
final Object o = constructor.newInstance(123);
System.out.println("o = " + o);
答案 27 :(得分：-1)
这是一个基于ParameterizedType.getActualTypeArguments的改进的解决方案，@ noah，@ Lars Bohl和其他一些人已经提到过。
实施中的第一个小改进。工厂不应返回实例，而应返回类型。使用Class.newInstance()返回实例后，便会缩小使用范围。因为只能像这样调用无参数构造函数。更好的方法是返回类型，并允许客户端选择他要调用的构造函数：
public class TypeReference<T> {
public Class<T> type(){
try {
ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();
if (pt.getActualTypeArguments() == null || pt.getActualTypeArguments().length == 0){
throw new IllegalStateException("Could not define type");
}
if (pt.getActualTypeArguments().length != 1){
throw new IllegalStateException("More than one type has been found");
}
Type type = pt.getActualTypeArguments()[0];
String typeAsString = type.getTypeName();
return (Class<T>) Class.forName(typeAsString);
} catch (Exception e){
throw new IllegalStateException("Could not identify type", e);
}
}
}
这是一个用法示例。 @Lars Bohl仅显示了一种通过扩展获得通用基因的简单方法。 @noah仅通过使用{}创建实例来实现。这是演示这两种情况的测试：
import java.lang.reflect.Constructor;
public class TypeReferenceTest {
private static final String NAME = "Peter";
private static class Person{
final String name;
Person(String name) {
this.name = name;
}
}
@Test
public void erased() {
TypeReference<Person> p = new TypeReference<>();
Assert.assertNotNull(p);
try {
p.type();
Assert.fail();
} catch (Exception e){
Assert.assertEquals("Could not identify type", e.getMessage());
}
}
@Test
public void reified() throws Exception {
TypeReference<Person> p = new TypeReference<Person>(){};
Assert.assertNotNull(p);
Assert.assertEquals(Person.class.getName(), p.type().getName());
Constructor ctor = p.type().getDeclaredConstructor(NAME.getClass());
Assert.assertNotNull(ctor);
Person person = (Person) ctor.newInstance(NAME);
Assert.assertEquals(NAME, person.name);
}
static class TypeReferencePerson extends TypeReference<Person>{}
@Test
public void reifiedExtenension() throws Exception {
TypeReference<Person> p = new TypeReferencePerson();
Assert.assertNotNull(p);
Assert.assertEquals(Person.class.getName(), p.type().getName());
Constructor ctor = p.type().getDeclaredConstructor(NAME.getClass());
Assert.assertNotNull(ctor);
Person person = (Person) ctor.newInstance(NAME);
Assert.assertEquals(NAME, person.name);
}
}
注意：您可以通过将此类抽象为TypeReference来强制创建实例时{}的客户端始终使用public abstract class TypeReference<T>。我没有这样做，只是为了显示已删除的测试用例。