Java 无法创建OuterClass的常规数组<；T>；。下层阶级

我有这个密码

public class OuterClass<T> {
    public OuterClass() {
        InnerClass[] array = new InnerClass[4]; // compile-error
    }

    private class InnerClass {

    }
}

公共类外部类{
公共外类（）{
InnerClass[]数组=新的InnerClass[4]；//编译错误
}
私有类内部类{
}
}

由于无法在创建数组的行中创建OuterClass.InnerClass的泛型数组，因此无法编译

---

为什么会这样？我如何修复/解决它？

解决方法：使内部类成为静态类

public class OuterClass<T> {
    public OuterClass() {
        InnerClass[] array = new InnerClass[4];
    }

    private static class InnerClass {

    }
}

公共类外部类{
公共外类（）{
InnerClass[]数组=新的InnerClass[4]；
}
私有静态类InnerClass{
}
}

您有一个参数化问题。泛型现在需要知道类型，它正在处理什么。整数、双精度、浮点；等等，在编译时。该类型会向下延伸到封装的类，但不会指定类型（outerclass.innerclass），这就是出现问题的原因（请参见newacct）

因此，您需要参数化InnerClass，因为它不知道正在处理什么。把这个班带出外面的班是可行的

但是，对内部类的修复也是如此

 package quicktest;

 public class OJust<T>{
      public OJust() {
         InnerClass[] array = new InnerClass[4]; // compile-error
     }

     private class InnerClass<T>{

     }

packagequicktest；
公共类OJust{
公共部门{
InnerClass[]数组=新的InnerClass[4]；//编译错误
}
私有类内部类{
}

---

}

内部类

是一个非静态的内部类。

OuterClass

的非静态成员在

OuterClass

的类型参数

T

的范围内。这意味着

内部类

是隐式泛型的

每次在

OuterClass

的实例上下文中，您只编写

InnerClass

，而不显式限定它时，它都被隐式地视为

OuterClass.InnerClass

。所以当你写信的时候

InnerClass[] array = new InnerClass[4];

编译器将其视为

OuterClass<T>.InnerClass[] array = new OuterClass<T>.InnerClass[4];
//                                                ^
// see? you are using "new" to create an array of a parameterized type

或通配符参数化类型：

List<T>[] = (List<T>[])new List<?>[4]; // legal

或者使用通配符参数化类型（同样，我们必须将通配符放在

OuterClass

）：

InnerClass[]=（InnerClass[]）新的外部类。InnerClass[4]；//合法的

当心静力学。他们无法访问您的类中的任何其他内容。首先实例化静态类，它们的生存期是类v的生存期。物体。这意味着实例变量将不能与内部类一起工作。有很多方法可以解决这个问题。InnerClass可以保存OuterClass的实例，并可以通过该实例访问OuterClass的非静态成员。听起来有点循环/过于复杂。我没有降低分数或做任何事情，因为这是可行的。我知道让内部类保持静态是可行的。你的第二个想法正是我目前的解决方法，似乎效果不错。然而，另一个答案正是我想要的。我很想知道这是如何复制的。相关问题与此没有直接关系。我不想创建一个通用数组。艾斯，你说得对-它与重复问题无关。我重新打开了你的问题，可能这条线索也会有帮助：很好！我不知道这件事。谢谢：）这是个糟糕的主意。内部类仍然由外部

T

参数化，但现在有一个单独的内部参数

T

隐藏它。所以它不只是继承为T传递的任何内容？

List<T>[] = (List<T>[])new List<?>[4]; // legal

InnerClass[] = new OuterClass.InnerClass[4]; // legal

InnerClass[] = (InnerClass[])new OuterClass<?>.InnerClass[4]; // legal