Java 是否有更干净的方法初始化此通用数组？

昨天我尝试创建一个对象数组，属于泛型类的非静态内部类。似乎没有什么好办法

---

第一次尝试：

public class Wibble<T>{  
      public static void main(String...args){  
            new Wibble<String>();  
      }  
      public Wibble(){  
            Bar[] bar = new Bar[11];  
      }  
      static class Foo{}  
      class Bar extends Foo{}  
}

public class Wibble<T> {  
      public static void main(String...args){  
            new Wibble<String>();  
      }  
      public Wibble(){  
            Bar[] bar = (Bar[])new Foo[11];  
      }  
      static class Foo{}  
      class Bar extends Foo{}  
}  

public class Wibble<T> {  
      private static final Class<?> BARCLASS = new Wibble<Object> (false).new Bar().getClass();  
      public static void main(String...args){  
           new Wibble<String>();  
      }  
      private Wibble(boolean flag){}
      public Wibble(){  
           Bar[] bar = (Bar[])Array.newInstance(BARCLASS, 11);  
      }  
      static class Foo{}  
      class Bar extends Foo{}  
}

公共类Wibble{
公共静态void main（字符串…参数）{
新Wibble（）；
}  
公共Wibble（）{
棒材[]棒材=新棒材[11]；
}  
静态类Foo{}
类栏扩展了Foo{}
}

这不起作用，因为“Wibble”上下文中的“Bar”是隐式泛型的，导致以下错误：

Exception in thread "main" java.lang.Error:  
Unresolved compilation problem: Cannot create a generic array of Wibble<T>.Bar  

at Wibble.<init>(Wibble.java:7)  
at Wibble.main(Wibble.java:4)  

Exception in thread "main" java.lang.ClassCastException:  
[LWibble$Foo; cannot be cast to [LWibble$Bar;  

at Wibble.<init>(Wibble.java:7)  
at Wibble.main(Wibble.java:4)

线程“main”java.lang中出现异常。错误： 未解决的编译问题：无法创建Wibble.Bar的通用数组 在Wibble。（Wibble.java:7） 位于Wibble.main（Wibble.java:4）

---

第二次尝试：

public class Wibble<T>{  
      public static void main(String...args){  
            new Wibble<String>();  
      }  
      public Wibble(){  
            Bar[] bar = new Bar[11];  
      }  
      static class Foo{}  
      class Bar extends Foo{}  
}

public class Wibble<T> {  
      public static void main(String...args){  
            new Wibble<String>();  
      }  
      public Wibble(){  
            Bar[] bar = (Bar[])new Foo[11];  
      }  
      static class Foo{}  
      class Bar extends Foo{}  
}  

public class Wibble<T> {  
      private static final Class<?> BARCLASS = new Wibble<Object> (false).new Bar().getClass();  
      public static void main(String...args){  
           new Wibble<String>();  
      }  
      private Wibble(boolean flag){}
      public Wibble(){  
           Bar[] bar = (Bar[])Array.newInstance(BARCLASS, 11);  
      }  
      static class Foo{}  
      class Bar extends Foo{}  
}

公共类Wibble{
公共静态void main（字符串…参数）{
新Wibble（）；
}  
公共Wibble（）{
Bar[]Bar=（Bar[]）新Foo[11]；
}  
静态类Foo{}
类栏扩展了Foo{}
}  

这不起作用，因为数组只能从最近已知的非泛型类型转换为泛型类型。对于泛型条，最近已知的非泛型类型是非泛型条，它不能（容易地）在父类的上下文中被引用。导致以下错误：

Exception in thread "main" java.lang.Error:  
Unresolved compilation problem: Cannot create a generic array of Wibble<T>.Bar  

at Wibble.<init>(Wibble.java:7)  
at Wibble.main(Wibble.java:4)  

Exception in thread "main" java.lang.ClassCastException:  
[LWibble$Foo; cannot be cast to [LWibble$Bar;  

at Wibble.<init>(Wibble.java:7)  
at Wibble.main(Wibble.java:4)

线程“main”java.lang.ClassCastException中的异常： [LWibble$Foo；无法强制转换为[LWibble$Bar； 在Wibble。（Wibble.java:7） 位于Wibble.main（Wibble.java:4）

---

最后一次尝试：

public class Wibble<T>{  
      public static void main(String...args){  
            new Wibble<String>();  
      }  
      public Wibble(){  
            Bar[] bar = new Bar[11];  
      }  
      static class Foo{}  
      class Bar extends Foo{}  
}

public class Wibble<T> {  
      public static void main(String...args){  
            new Wibble<String>();  
      }  
      public Wibble(){  
            Bar[] bar = (Bar[])new Foo[11];  
      }  
      static class Foo{}  
      class Bar extends Foo{}  
}  

public class Wibble<T> {  
      private static final Class<?> BARCLASS = new Wibble<Object> (false).new Bar().getClass();  
      public static void main(String...args){  
           new Wibble<String>();  
      }  
      private Wibble(boolean flag){}
      public Wibble(){  
           Bar[] bar = (Bar[])Array.newInstance(BARCLASS, 11);  
      }  
      static class Foo{}  
      class Bar extends Foo{}  
}

公共类Wibble{
私有静态最终类BARCLASS=new-Wibble（false）.new-Bar（）.getClass（）；
公共静态void main（字符串…参数）{
新Wibble（）；
}  
私有Wibble（布尔标志）{}
公共Wibble（）{
Bar[]Bar=（Bar[]）Array.newInstance（BARCLASS，11）；
}  
静态类Foo{}
类栏扩展了Foo{}
}

但是，如果您希望在构造函数中创建数组，则还需要一个（私有）伪构造函数，以便获得该类。
此外，如果父类是抽象的，则需要为所有抽象方法提供虚拟实现

---

当我写完这篇文章时，我意识到

public class Wibble<T> {    
      public static void main(String...args){  
            new Wibble<String>();  
      }  
      private Wibble(boolean flag){}
      public Wibble(){  
            Bar[] bar = (Bar[])Array.newInstance(Bar.class, 11);  
      }  
      static class Foo{}  
      class Bar extends Foo{}  
}

公共类Wibble{
公共静态void main（字符串…参数）{
新Wibble（）；
}  
私有Wibble（布尔标志）{}
公共Wibble（）{
Bar[]Bar=（Bar[]）Array.newInstance（Bar.class，11）；
}  
静态类Foo{}
类栏扩展了Foo{}
}

---

同样有效，我想我还是发布一下吧。不过这仍然很难看，而且没有理由认为正常语法不起作用。

如果您也将

Bar

声明为静态类，那么以下代码（即最明显的代码）将在编译和运行时都起作用：

Bar[] bar = new Bar[11];

编辑

---

使用java.lang.reflect.Array.newInstance是在运行时分配新的通用数组的首选方法

如果您也将

Bar

声明为静态类，则以下代码（即最明显的代码）将在编译和运行时都起作用：

Bar[] bar = new Bar[11];

编辑

---

使用java.lang.reflect.Array.newInstance是在运行时分配新泛型数组的首选方法

如果需要保持“隐式泛型”，即不能使类保持静态，则可以执行

Bar[]Bar=new Bla.Bar[11]；

，但会收到警告。

如果需要保持“隐式泛型”，也就是说，您不能将类设置为静态，您可以执行

Bar[]Bar=new Bla.Bar[11]；

，尽管您会因此收到警告。

List Bar=new ArrayList（）；
List<Bar> bars = new ArrayList<Bar>();

已排序（er，ordered）。

列表栏=新的ArrayList（）；

---

已排序（er，ordered）。

已重新格式化，但问题到底是什么？您的第一个示例对我来说很好。我不确定您所说的隐式泛型是什么意思，并且您的示例中没有任何泛型。堆栈溢出是否会删除您的“”（使用“格式为代码”按钮）@Steve B.你确定你使Bar类成为非静态的吗？Bar类是泛型的；假设你有一些Wibble Wibble，在Wibble中，任何Bar（假设Bar是非静态的内部类）都有一个隐式泛型类型“String”。@Rich Seller我基本上回答了我自己的（原创）当我意识到Bar.class可以直接使用时的问题（导致（Bar[]）Array.newInstance（Bar.class，Array_size））.我的问题，在某种程度上，后来变成了一个关于语言的问题-为什么在运行时类型可以很容易推断的情况下，条形数组的初始化会被视为泛型数组的初始化？这些问题有一个很好的总结，以及为什么您的大多数方法都有效而无效。重新格式化，但具体的qu是什么estion？您的第一个示例对我来说编译得很好。我不确定您所说的隐式泛型是什么意思，并且您的示例中没有任何泛型。堆栈溢出是否会删除您的？（使用“格式为代码”按钮）@Steve B.你确定你使Bar类成为非静态的吗？Bar类是泛型的；假设你有一些Wibble Wibble，在Wibble中，任何Bar（假设Bar是非静态的内部类）都有一个隐式泛型类型“String”。@Rich Seller我基本上回答了我自己的（原创）当我意识到Bar.class可以直接使用时的问题（导致（Bar[]）Array.newInstance（Bar.class，Array_size））在某种程度上，我的问题变成了一个关于语言的问题——为什么在运行时类型可以很容易推断的情况下，条形数组的初始化会被视为泛型数组的初始化？这些问题有一个很好的总结，以及为什么您的大多数方法都有效，而不有效。在我的实际代码中，非