为什么不能使用“new”运算符创建泛型类型的实例？

Question

我发现了很多关于如何 克服这个限制的帖子，但没有一个关于为什么存在这个限制的帖子（this one 除外，它只是提到它与类型擦除有关）。

那么为什么不能创建一个泛型类型的实例呢？

澄清一下，我的问题不是如何它可以做到。我知道这在 C# 中是可能的，那么为什么不在 Java 中呢？我很好奇为什么 Java 人没有实现类似的机制？为什么要强制 Java 开发人员使用可能导致运行时错误的笨拙变通方法？这种机制有没有潜在的危害？

Answer 1

简答： Java 是compiled programming language，这意味着您的字节码在运行时是不变的。如果E 未知，则无法为new E() 生成字节码。

说明：通用信息为erased in runtime：

public class Container<E> {
     private E item;
     public E getItem() {return item;}
}
class BoxWithPresent extends Container<Present> {
}
class SimpleBox extends Container {
}

在字节码类BoxWithPresent 中包含item 类型的Present 字段，但SimpleBox 类包含item 类型Object 的字段（因为未指定E 类型）。

现在你写抽象实例化方法：

public class Container<E> {
    public <E> E createE() {
        return new E(); // imagine if that was allowed
    }
}

这里应该生成什么字节码？ .class 文件现在在编译时生成，但我们不知道 E 是什么类型。

那么.. new T() 可以替换为 new Object() 吗？坏主意，BoxWithPresent 类不会喜欢它，因为它认为 E 是 Present。

可以换成class.newInstance()吗？同样不，方法范围内没有class 变量。

这就是为什么new E() 是不可能的。
但是有一些解决方法是将class 作为参数传递，或者extracting generic information。

Answer 2

最短的答案是泛型类型参数在运行时不存在。

泛型在第 5 版中被改进为 Java 语言。为了保持与现有代码库的向后兼容性，它们通过 erasure 实现。

泛型类型参数在编译时存在于您的源代码中，但在编译过程中，几乎所有关于它们的证据都会从字节码中删除。之所以选择这种泛型实现，是因为它维护了预泛型代码和 Java 5+ 泛型代码之间的互操作性。因此，泛型的类型安全在很大程度上是仅编译时的现象。如果你的泛型代码编译没有错误和警告，那么你就确信你的代码是类型的安全。

但是，由于擦除，（从 Java 5 开始）有两种类型：

• 可具体化。例如String、Integer 等。可具体化类型在编译时与运行时具有相同的类型信息。

• 不可具体化。例如List<String>、List<T> 和T。不可具体化类型在运行时的类型信息少于编译时的类型信息。其实上面的运行时类型有List、List、Object。在编译期间，泛型类型信息被删除。

您不能将new 运算符用于不可具体化的类型，因为在运行时没有类型安全的方式让 JVM 生成正确类型的对象。

源代码：

T myObject = new T();

以上内容无法编译。在运行时，T 已被删除。

规避类型擦除和 Java 泛型问题的一种策略是使用类型标记。此策略在以下通用方法中实现，该方法创建一个新的T 对象：

public <T> T newInstance(Class<T> cls) {
    T myObject = cls.newInstance();
    return myObject;
}

泛型方法从作为参数传递的Class 对象中捕获类型信息。此参数称为类型标记。不幸的是，类型标记本身必须始终是可具体化的（因为您无法获得不可具体化类型的 Class 对象），这会限制它们的用处。

Answer 3

从泛型创建一个类。请注意，这依赖于被参数化的类。这将返回泛型的类对象，您可以通过它进行进一步的反射以创建对象。

 public static <T> Class<T> getClassFromGeneric(
            Object parentObj,
            int oridnalParamterizedTypeIndex) throws Exception{
          Type[] typeArray = getParameterizedTypeListAsArray(parentObj);
          return (Class<T>)typeArray[oridnalParamterizedTypeIndex];
    }

    public static <T> Type[] getParameterizedTypeListAsArray(Object parentObj){
        try{
            return  ((ParameterizedType) parentObj.getClass()
                    .getGenericSuperclass())
                    .getActualTypeArguments();
        }
        catch(ClassCastException e){
            logger.log(Level.SEVERE, "Most likely, somewhere in your inhetirance chain,"
                    + "there is a class that uses a raw type and not the generic param."
                    + "See: http://stackoverflow.com/questions/23074446/java-lang-classcastexception-java-lang-class-cannot-be-cast-to-java-lang-reflec"
                    + " for more info",e);
            throw e;
        }
    }

用法：

public class GenericBaseClass<T>{}
public class GenericImpl extends GenericBaseClass<String>{
    public static void main(String[] args){
        new GenericImpl();
    }

    public GenericImpl(){
        Class tClazz = getClassFromGeneric(this,0);
        Constructor constructor = tClazz.getConstructor();
        T newT = constructor.newInstance();
    }
}

与普遍看法相反，班级级别的通用信息并未“删除”。

Answer 4

请记住，泛型类型是关于编译时安全的。类型的编译时检查允许编译器向您提供有关代码问题的警告/错误。这并不能直接帮助您解决问题，但重要的是要保持编译时和运行时的概念非常清晰。

您不能说“return new T()”，因为编译器无法知道该怎么做。如果没有特定的类型，编译器就无法知道要调用什么构造函数，甚至无法知道它是否存在。此外，为了“新建”T 类型的实例，您需要调用一些东西。 T 只是一个符号。它不是Class 或Object。在您提供有关 T 是哪种实例的信息（例如 List<String>）之前，编译器无法执行您正在尝试执行的操作。

键入只是确保给定和返回的类型在编译时正确匹配的一种方式。当您指定类型细节时，您可以创建它的实例。这就是为什么您通常会在接口上看到完全开放的类型（例如List<T>、Function<T,R> 等）。因此接口的实现者可以指定将使用的类型。

也许考虑像模板这样的泛型会有所帮助。不是软件开发模式，而是更抽象的概念。模板的概念表明这种结构没有任何内部细节。如果您想按照模板创建这个东西，请使用模板作为您的起点，但是您必须填写详细信息来制作这个东西。泛型类型有点像 - 它允许您构建某些东西，但不提供有关该结构中发生的任何细节。

我知道当引入泛型时，我在这方面遇到了很多困难。起初，我发现先为特定类型编写实现然后使用泛型将其抽象出来是最容易的。在了解泛型之后，我现在发现从泛型接口开始然后实现它更容易。