to cxz7531:数组不是对象这种说法没有任何依据。 实际上，jre管理着一个用以生成数组的类，这个类和Object有着几乎一模一样的接口，除了多了一个只读属性length。 java的数组是Object，这一点是肯定的，任何时候你都可以把一个数组当作一个Object来用。实际上，你完全可以把数组类当作Object的子类来对待（比如完全可以向需要Object参数的方法传入一个数组，因为数组 “is a” Object）。 所以说，java的数组是封装过的，和c/c++中的“低级”数组完全不同。to raojl:“对象”这个术语不仅仅是问题领域的概念。恰恰相反，当涉及到一个编程语言时，我们注意的更多的是实现领域的问题。否则，我们就不是在讨论java了，而是在讨论一般层面的OOP。 另外，我讨论的不仅仅是内存，在java中，everything is an Object，除了引用和简单类型（因为它们不是动态地在堆上创建的）。所以，运行时创建的一切都是Object。 java不是要屏蔽对内存的管理，而是要让内存管理更简单（只要掌握一些既定规则即可），所以你必须了解java的内存机制才能做到管理内存。
new int[3][][] 一个对象 new int[3][2][] 1+3个对象 new int[3][2][2] 1+3+6个对象 new int[3][2][]==》array=new int[3][][]; array[0]=new int[2][]; array[1]=new int[2][]; array[2]=new int[2][];
只不过这个数组被分配了很多空间你用多new一个 就多一个对象
只是对象的大小不同罢了就像：int[][][] array = new int[3][2][2]; //3维数组
int[] array2 = new int[3]； //1维数组
new int[3][2][] // 这时创建了3个数组，每个包含2个元素null
new int[3][2][2] // 这时创建了6个数组，每个包含2个元素0所以一共是10个数组。
* @author haihai
*
*/
public class TestMain {
public TestMain() {
int[][][] array = new int[3][2][2];
int count=0;
for(int i=0;i<array.length;i++){
for(int j=0;j<array[i].length;j++){
for(int k=0;k<array[i][j].length;k++){
array[i][j][k]=count++;
}
}
}
for(int i=0;i<array.length;i++){
for(int j=0;j<array[i].length;j++){
for(int k=0;k<array[i][j].length;k++){
System.out.print(array[i][j][k]+"\t");
}
System.out.println();
}
System.out.println();
}
} public static void main(String[] args) {
new TestMain();
}
}
这个数组中存放的是对象的话,应该是12个
int[][][] array = new int[3][2][2]; 与 int[][][] array = new int[3][2][0];创建的对象是一样的吗？
这个问题的关键是，java中所谓的“多维数组”只是存储了指向数组的引用的数组，而不是矩阵。因此，一个多维数组不可能由一个对象担当。
楼主例子中的三维数组的内存结构如下图：
to认为创建了12个对象的人，思路不对。
private a1 = "1"; //1
private a1 = "2"; //2
private a1 = "3"; //3
private a1 = "4"; //4
private a1 = "5"; //5
private a1 = "4"; //6
private a1 = "3"; //7
private a1 = "2"; //8
private a1 = "1"; //9
}new A()创建了多少个对象
private String a1 = "1";
private String a2 = "2";
private String a3 = "3";
private String a4 = "4";
private String a5 = "5";
private String a6 = "4";
private String a7 = "3";
private String a8 = "2";
private String a9 = "1";
}那么，new A()创建了6个对象。
A的实例本身是一个，字符串字面量"1"，"2"，"3"，"4"，"5"各一个对象。
因为相同的字符串字面量不会再次创建，所以当执行到private String a6 = "4";时，不再创建对象了，只创建一个引用（引用不算对象）。余下同理。
int[][][] sss=new int[3][2][2];
System.out.println(sss);
for(int i=0;i<sss.length;i++){
System.out.println(sss[i]);
for(int j=0;j<sss[i].length;j++){
System.out.println(sss[i][j]);
for(int k=0;k<sss[i][j].length;k++){
// System.out.println(sss[i][j][k]);
}
}
}如果定义成这样int[][][] sss=new int[3][][];就只有一个对象了。
不过你对JAVA内存管理可谓是到家了，佩服！！！！！
实际上，jre管理着一个用以生成数组的类，这个类和Object有着几乎一模一样的接口，除了多了一个只读属性length。
java的数组是Object，这一点是肯定的，任何时候你都可以把一个数组当作一个Object来用。实际上，你完全可以把数组类当作Object的子类来对待（比如完全可以向需要Object参数的方法传入一个数组，因为数组 “is a” Object）。
所以说，java的数组是封装过的，和c/c++中的“低级”数组完全不同。to raojl:“对象”这个术语不仅仅是问题领域的概念。恰恰相反，当涉及到一个编程语言时，我们注意的更多的是实现领域的问题。否则，我们就不是在讨论java了，而是在讨论一般层面的OOP。
另外，我讨论的不仅仅是内存，在java中，everything is an Object，除了引用和简单类型（因为它们不是动态地在堆上创建的）。所以，运行时创建的一切都是Object。
java不是要屏蔽对内存的管理，而是要让内存管理更简单（只要掌握一些既定规则即可），所以你必须了解java的内存机制才能做到管理内存。
1.array
2.array[0]
3.array[1]
4.array[2]
5.array[0][0]
6.array[0][1]
7.array[1][0]
8.array[1][1]
9.array[2][0]
10.array[2][1]
针对楼主所说的问题，应该是一个int [3][2][2]对象，其中包含3个int [2][2]对象，每个int [2][2]对象又包含2个int [2]对象。如果是new int[3][][]，则只生成int [3][][]对象，其中三个二维数组元素还没有生成对象。to Dan1980：
你的解释很好，让我见识不少，特别是你的图示。但正如Rayjl所说的，你展示了一个int [3][2][2]对象的内存存储状况，正是那十个内存块，才构成一个int [3][2][2]对象。至于你讲的十个对象是算完整体的，再算里面局部的，就想算完中国这个对象后再算上海这个对象一样。总的来说谈对象不能脱离类型！
借问一个问题，下面这个类 public class A{
private a1 = "1 "; //1
private a1 = "2 "; //2
private a1 = "3 "; //3
private a1 = "4 "; //4
private a1 = "5 "; //5
private a1 = "4 "; //6
private a1 = "3 "; //7
private a1 = "2 "; //8
private a1 = "1 "; //9
} new A()创建了多少个对象
我提出这个问题来本是想说明研究这个并无多大意义，这上面的属性是已知的，如果给一个未知的类,UnknowClass
然后问你new UnknowClass()会创建多少个对象，没多大意义
我也认为是10个
这个就是引用的个数三
int型的还好
用引用类型的话好象会出空指针的错误
我以前就犯过的
用Ｃ来想的话就是定义了一个三级指针吧
new int[3][2][] 1+3个对象
new int[3][2][2] 1+3+6个对象
new int[3][2][]==》array=new int[3][][];
array[0]=new int[2][];
array[1]=new int[2][];
array[2]=new int[2][];
-------------------------
顶这句