1

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

这行得通吗？

4

5 回答 5

1

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

public Outerclass

应该

public class Outerclass

和内在一样！

其次，代码的最后一部分都应该在一个main()方法 INSIDE Ourclass 中。

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

        Outerclass oc = new Outerclass();
        Outerclass.InnerClass in = oc.new InnerClass();
于 2013-08-05T00:28:09.260 回答
1

对答案 #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
        }
    }
}

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

oc = new OuterClass( vars ...)
var = oc.InnerClassInstances.get(i).icvar
于 2016-09-28T19:35:50.133 回答
0

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

你不能像你正在做的那样InnerClass自己创建它new，你说它需要访问其OuterClass实例的成员，正如你在代码中看到的那样，对于每一个new InnerClass()你从不以任何方式指定OuterClass实例是什么为了它。

于 2013-08-05T00:35:25.727 回答
0

以下是代码的关键行：

 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。

  2. 如果InnerClass是，static这也没有必要。但是InnerClass根据标准Java术语，嵌套类不是内部类。

于 2013-08-05T00:20:51.590 回答
0

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

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

    }
}
于 2013-08-05T00:22:37.703 回答