具有外部类和内部类的数组

我对Java还比较陌生。我想创建一个外部类的arraylist，对于arraylist的外部类的每个索引，我想要一个内部类的arraylist。

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);
 }

这行得通吗？

首先，我认为你应该在开始跑步之前学会走路：

public Outerclass

应该是

public class Outerclass

和内在的一样！

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

第三，不，你不能这样使用内部类，这就是为什么这些类是内部的。如果你想从main()内部或外部类外部使用内部类，你必须使用外部类的实例才能访问它们，就像访问任何其他实例成员一样——你不能直接访问它：

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

如果您有用于数据存储的嵌套类，那么答案#2的litte精化意味着您有一个外部类的构造函数，它会像树结构一样自动为内部类生成可变数量的数组成员。该解决方案实际上是一种变通方法，它使用一个已定义的成员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
        }
    }
}

从外部，您可以使用get:访问InnerClass实例

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

以下是代码的关键行：

 Outerclass c = new Outerclass ();
     InnerClass e = new InnerClass();

那行不通。您将得到一个编译错误。

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

 Outerclass c = new Outerclass ();
     InnerClass e = c.new InnerClass();

c.new ...形式被称为限定类实例创建表达式；参见JLS 15.9。

注：

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

内部类的实例只能存在于外部类的实例中。（有关静态和非静态内部类之间的区别，请参阅此答案以获取更多信息）。

这意味着在外部对象中创建内部对象。您可以将其视为创建并包含内部对象的外部对象（因此命名为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 {
    }
}

既然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实例是什么。

相关内容

最新更新

热门标签：