阵列与外部和内部类

Question

我是比较新到Java。我想创建一个外部类的数组列表，并且对于数组列表的外部类的每个索引，我想要一个内部类的数组列表。

public Outerclass{ 

    //Code Here 

    public InnerClass{ 
    //Code Here 
    } 
} 

//My attempt at setting up the arrays 
public ArrayList <Outerclass> olist; 
public ArrayList <InnerClass> ilist; 


olist= new ArrayList<Outerclass>(); 
for (int i = 0; i < 3; i++) { 
     Outerclass c = new Outerclass(); 
     ilist = new ArrayList<InnerClass>(); 
     for(int j = 0 ; j < 4; j++){ 
      InnerClass e = new InnerClass(); 
      ilist.add(e); 
     } 
     olist.add(c); 
} 

这项工作？

Answer 1

这里是你的代码的关键线路：

Outerclass c = new Outerclass(); 

    InnerClass e = new InnerClass(); 

这是行不通的。你会得到一个编译错误。

由于InnerClass是一个内部类，它需要在它的封闭类的实例（即OuterClass）的上下文中实例化。像这样：

Outerclass c = new Outerclass(); 

    InnerClass e = c.new InnerClass(); 

的c.new ...形式被称为合格的类实例创建表达式;请参阅JLS 15.9。

注：

1. 如果创建内部类的代码是在外部类的一个实例的上下文中（例如，它是在外部类的实例方法），那么你不需要像这样符合new。如果InnerClass是static这也不是必需的。但是，根据标准Java术语，InnerClass是嵌套类，不是内部类。

Answer 2

内部类的实例只能存在于外部类的实例中。 （有关静态内部类和非静态内部类的区别，请参见this answer了解更多信息）。

这意味着您创建内部对象内外的物体。你可以把它作为外部对象创建和包含内部对象（故名inner）

下面是一个例子：

import java.util.ArrayList; 

public class OuterClass { 
    static ArrayList<InnerClass> innerClasses = new ArrayList<InnerClass>(); 

    public static void main(String[] args) { 
     OuterClass oc1 = new OuterClass(); 
     OuterClass.InnerClass ic1 = oc1.new InnerClass(); 
     OuterClass.InnerClass ic2 = oc1.new InnerClass(); 
     innerClasses.add(ic1); 
     innerClasses.add(ic2);  
     System.out.println(innerClasses.size()); 
    } 
    class InnerClass { 

    } 
} 

Answer 3

首先，我认为你应该学会如何在你开始之前走路运行：

public Outerclass 

应该

public class Outerclass 

同样有内！

其次，你的代码中所有的最后部分应该在main()方法中Ourclass。

;第三，不，你不能使用这样的内部类，这就是为什么这些类内。如果要使用main()以内的内部类或者外部类的外部类，则必须使用外部实例才能访问它们，与访问任何其他实例成员相同 - 不能直接访问它：

 Outerclass oc = new Outerclass(); 
     Outerclass.InnerClass in = oc.new InnerClass(); 

Answer 4

鉴于InnerClass需要保持参考OuterClass的成员，我想知道你为什么不把ArrayList<InnerClass>内OuterClass。如果他们以这种方式正在由它更有道理由OuterClass有“管理”列表中，只是给它的接入方式返回InnerClass实例等的列表

因此，像这样：

public class OuterClass 
{ 
    private List<InnerClass> innerClassInstances = new ArrayList<>; 

    public void addInnerInstances(int count) 
    { 
     for(int j = 0 ; j < count; j++) 
     { 
     InnerClass e = new InnerClass(); 
     innerClassInstances.add(e); 
     } 
    } 

    public List<InnerClass> getInnerClassInstances() 
    { 
     return innerClassInstances; 
    } 

    public class InnerClass 
    { 
    //... 
    } 
} 

    //in your main class or wherever 
    List<Outerclass> olist; 

    olist= new ArrayList<Outerclass>(); 
    for (int i = 0; i < 3; i++) 
    { 
     Outerclass c = new Outerclass(); 
     c.addInnerInstances(4); 
     olist.add(c); 
    } 

你不能用new创建它自身的InnerClass为你做的，你说，它需要访问它OuterClass实例的成员，你可以在你的代码中看到，每个new InnerClass()你永远不会以任何方式指定它的实例OuterClass。

Answer 5

答案＃2的小细节，如果你有数据存储的嵌套类，意味着你有一个外部类的构造函数，它自动为内部类生成一个可变数量的数组成员，如树结构。这个解决方案实际上是一种解决方法，它使用一个定义的成员 - 一个ArrayList - 它可以稍后扩展，而不是在OuterClass内的InnerClass []数组的直接定义，如果它不是静态的，它将不起作用。

public class OuterClass 
{ 
    private int NumberInnerClassInstances;  
    // ... other members of OuterClass 
    ArrayList<InnerClass> innerClassInstances = new ArrayList<>(); 

    OuterClass(input vars ...) { 
     // calculate the NumberInnerClassInstances needed 
     for(int i = 0 ; j < NumberInnerClassInstances; i++) { 
      OuterClass.InnerClass in = this.new InnerClass(i); 
      innerClassInstances.add(in); 
     } 
    } 

    public class InnerClass 
    { 
     int icvar; 
     InnerClass(int i) { 
      //...construct the Inner Class Member #i 
      // can access the members of OuterClass 
     } 
    } 
} 

从外面，然后你可以得到Access的实例将InnerClass：

oc = new OuterClass(vars ...) 
var = oc.InnerClassInstances.get(i).icvar