在Java中实例化一个泛型类[重复]

Question

我知道 Java 的泛型不如 .Net 的。

我有一个通用类Foo<T>，我真的需要使用无参数构造函数在Foo 中实例化一个T。如何解决 Java 的限制？

Answer 1

一种选择是传入Bar.class（或您感兴趣的任何类型 - 指定适当Class<T> 引用的任何方式）并将该值保留为字段：

public class Test {
    public static void main(String[] args) throws IllegalAccessException,
            InstantiationException {
        Generic<Bar> x = new Generic<>(Bar.class);
        Bar y = x.buildOne();
    }
}

public class Generic<T> {
    private Class<T> clazz;

    public Generic(Class<T> clazz) {
        this.clazz = clazz;
    }

    public T buildOne() throws InstantiationException, IllegalAccessException {
        return clazz.newInstance();
    }
}

public class Bar {
    public Bar() {
        System.out.println("Constructing");
    }
}

另一种选择是拥有一个“工厂”接口，并将工厂传递给泛型类的构造函数。这样更加灵活，而且您无需担心反射异常。

Answer 2

这是工厂实现，如Jon Skeet suggested：

interface Factory<T> {
    T factory();
}

class Araba {
    //static inner class for Factory<T> implementation
    public static class ArabaFactory implements Factory<Araba> {
        public Araba factory() {
            return new Araba();
        }
    }
    public String toString() { return "Abubeee"; }
}

class Generic<T> {
    private T var;

    Generic(Factory<T> fact) {
        System.out.println("Constructor with Factory<T> parameter");
        var = fact.factory();
    }
    Generic(T var) {
        System.out.println("Constructor with T parameter");
        this.var = var;
    }
    T get() { return var; }
}

public class Main {
    public static void main(String[] string) {
        Generic<Araba> gen = new Generic<Araba>(new Araba.ArabaFactory());
        System.out.print(gen.get());
    }
}

输出：

Constructor with Factory<T> parameter
Abubeee

Answer 3

这是一种相当人为的方法，无需显式使用构造函数参数。你需要扩展一个参数化的抽象类。

public class Test {   
    public static void main(String [] args) throws Exception {
        Generic g = new Generic();
        g.initParameter();
    }
}

import java.lang.reflect.ParameterizedType;
public abstract class GenericAbstract<T extends Foo> {
    protected T parameter;

    @SuppressWarnings("unchecked")
    void initParameter() throws Exception, ClassNotFoundException, 
        InstantiationException {
        // Get the class name of this instance's type.
        ParameterizedType pt
            = (ParameterizedType) getClass().getGenericSuperclass();
        // You may need this split or not, use logging to check
        String parameterClassName
            = pt.getActualTypeArguments()[0].toString().split("\\s")[1];
        // Instantiate the Parameter and initialize it.
        parameter = (T) Class.forName(parameterClassName).newInstance();
    }
}

public class Generic extends GenericAbstract<Foo> {
}

public class Foo {
    public Foo() {
        System.out.println("Foo constructor...");
    }
}

Answer 4

我真的需要在 Foo 中使用无参数实例化一个 T 构造函数

简单的答案是“你不能那样做”java 使用类型擦除来实现泛型，这会阻止你这样做。

如何解决 Java 的限制？

一种方法（可能还有其他方法）是将您将传递 T 的实例的对象传递给 Foo<T> 的构造函数。或者你可以有一个方法 setBar(T theInstanceofT); 来获取你的 T 而不是在它自己的类中实例化。

Answer 5

对于 Java 8 ....

https://stackoverflow.com/a/36315051/2648077 帖子有一个很好的解决方案。

这里使用Java 8 Supplier功能接口

Answer 6

来自https://stackoverflow.com/a/2434094/848072。你需要一个 T 类的默认构造函数。

import java.lang.reflect.ParameterizedType;

class Foo<T> {
  
  public bar() {
    ParameterizedType superClass = (ParameterizedType) getClass().getGenericSuperclass();
    Class<T> type = (Class<T>) superClass.getActualTypeArguments()[0];
    try {
      T t = (T) type.getDeclaredConstructor().newInstance();
      //Do whatever with t
    } catch (Exception e) {
      // Oops, no default constructor
      throw new RuntimeException(e);
    } 
  }
}

Answer 7

Java 中的泛型通常比 C# 中的更强大。

如果您想构造一个对象但不使用构造函数/静态方法，请使用抽象工厂。您应该能够在任何基本设计模式书籍、OOP 简介或所有互联网上找到有关抽象工厂模式的详细信息和教程。在这里不值得重复代码，除了提到 Java 的闭包语法很烂。

IIRC，C# 有一个特殊情况，用于指定泛型类型具有无参数构造函数。根据定义，这种不规则性预设了客户端代码想要使用这种特殊的构造形式并鼓励可变性。

为此使用反射是错误的。 Java 中的泛型是一种编译时的静态类型特性。尝试在运行时使用它们清楚地表明出现了问题。反射会导致冗长的代码、运行时失败、未经检查的依赖关系和安全漏洞。 （Class.forName 特别邪恶。）

Answer 8

我可以在 JUnit 测试设置中执行此操作。

我想测试一个 Hibernate 外观，所以我一直在寻找一种通用的方法来完成它。请注意，外观还实现了一个通用接口。这里 T 是数据库类，U 是主键。 Ifacade<T,U> 是一个门面，用主键 U 访问数据库对象 T。

public abstract class GenericJPAController<T, U, C extends IFacade<T,U>>

{
    protected static EntityManagerFactory emf;

    /* The properties definition is straightforward*/
    protected T testObject;
    protected C facadeManager;

    @BeforeClass
    public static void setUpClass() {


        try {
            emf = Persistence.createEntityManagerFactory("my entity manager factory");

        } catch (Throwable ex) {
            System.err.println("Failed to create sessionFactory object." + ex);
            throw new ExceptionInInitializerError(ex);
        }

    }

    @AfterClass
    public static void tearDownClass() {
    }

    @Before
    public void setUp() {
    /* Get the class name*/
        String className = ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[2].getTypeName();

        /* Create the instance */
        try {
            facadeManager = (C) Class.forName(className).newInstance();
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex) {
            Logger.getLogger(GenericJPAController.class.getName()).log(Level.SEVERE, null, ex);
        }
        createTestObject();
    }

    @After
    public void tearDown() {
    }

    /**
     * Test of testFindTEntities_0args method, of class
     * GenericJPAController<T, U, C extends IFacade<T,U>>.
     * @throws java.lang.ClassNotFoundException
     * @throws java.lang.NoSuchMethodException
     * @throws java.lang.InstantiationException
     * @throws java.lang.IllegalAccessException
     */
    @Test
    public void  testFindTEntities_0args() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException {

        /* Example of instance usage. Even intellisense (NetBeans) works here!*/
        try {
            List<T> lista = (List<T>) facadeManager.findAllEntities();
            lista.stream().forEach((ct) -> {
                System.out.println("Find all: " + stringReport());
            });
        } catch (Throwable ex) {
            System.err.println("Failed to access object." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }


    /**
     *
     * @return
     */
    public abstract String stringReport();

    protected abstract T createTestObject();
    protected abstract T editTestObject();
    protected abstract U getTextObjectIndex();
}

Answer 9

使用Constructor.newInstance 方法。自 Java 9 起，Class.newInstance 方法已被弃用，以增强编译器对实例化异常的识别。

public class Foo<T> {   
    public Foo()
    {
        Class<T> newT = null; 
        instantiateNew(newT);
    }

    T instantiateNew(Class<?> clsT)
    {
        T newT;
        try {
            newT = (T) clsT.getDeclaredConstructor().newInstance();
        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
            | InvocationTargetException | NoSuchMethodException | SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
        return newT;
    }
}

Answer 10

对我有用的快速解决方案。 我看到已经有一个答案，这甚至可能不是最好的方法。另外，对于我的解决方案，您需要Gson。

但是，我遇到了需要创建java.lang.reflect.Type 类型的泛型类的实例的情况。

以下代码将使用空实例变量创建您想要的类的实例。

T object = new Gson().fromJson("{}", myKnownType);

myKnownType 事先已知并通过TypeToken.getType() 获得。

您现在可以在此对象上设置适当的属性。同样，这可能不是执行此操作的最佳方法，但如果您需要，它可以作为一种快速解决方案。