新手遇到的几个不理解的问题？

Question

1、java中的多维数组真难理解，和以往学过的其他语言的数组都不一样，如lotusscript,javascript，fortrain。教程上说java中数组不是连续有效的，太难理解了，那位高手能解释一下。
   教程中的例子和讲解，我不理解;
 第一个例子：int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};
  教程解释：Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维的大小相同。
最后一个数组值怎么变成了三位{3,4,5}};而前边都是两位：
  是不是intArray[0 ][ 0]={0,0}
       intArray[0 ][ 1]={2,3}
       intArray[1][ 1]={3,4,5}
我的理解对吗？第二此例子：
二维简单数据类型数组的动态初始化如下,
　　int a[ ][ ] = new int[2][ ]；
　　a[0] = new int[3];
　　a[1] = new int[5];　　对二维复合数据类型的数组，必须首先为最高维分配引用空间，然后再顺次为低维分配空间。
　　而且，必须为每个数组元素单独分配空间。
不明白的地方：为何第二个索引都没有指明，是个空的[].
第三个例子：
String s[ ][ ] = new String[2][ ];
　　s[0]= new String[2];//为最高维分配引用空间
　　s[1]= new String[2]; //为最高维分配引用空间
　　s[0][0]= new String("Good");// 为每个数组元素单独分配空间
　　s[0][1]= new String("Luck");// 为每个数组元素单独分配空间
　　s[1][0]= new String("to");// 为每个数组元素单独分配空间
　　s[1][1]= new String("You");// 为每个数组元素单独分配空间
该数组第二维没有指出索引，那如何知道是2，还付了数值
s[0][0]= new String("Good");// 为每个数组元素单独分配空间
　　s[0][1]= new String("Luck");// 为每个数组元素单独分配空间
　　s[1][0]= new String("to");// 为每个数组元素单独分配空间
　　s[1][1]= new String("You");// 

Answer 1

class A0 {
    A0() {
        System.out.println("父类的构造函数被调用（初始化父类）");
    }
}class A1 extends A0 {
    static final int b = print1();
    static {
        System.out.println("静态块被执行");
    }
    int a = print();
    {
        System.out.println("非静态块被执行");
    }    A1() {
        System.out.println("A1 的构造函数被调用");
    }    private int print() {
        System.out.println("A1中非静态变量被初始化");
        return 1;
    }    final static int print1() {
        System.out.println("A1中静态变量被初始化");
        return 1;
    }
}class A2 extends A1 {
    A2() {
        System.out.println("A2构造函数被调用");
    }
}public class DeriveDemo {
    public static void main(String[] args) {
        System.out.println("这是A1类的初始化顺序");
        A1 a = new A1();
        System.out.println("\n这是A2类的初始化顺序");
        A2 a1 = new A2();
        System.out.println("\n这是A2类的初始化顺序（注意静态变量）");
        A2 a2 = new A2();
        System.out.println("");
        System.out.println("我们还注意到静态变量被A2全盘继承下来了");
    }
}运行结果为
这是A1类的初始化顺序
A1中静态变量被初始化
静态块被执行
父类的构造函数被调用（初始化父类）
A1中非静态变量被初始化
非静态块被执行
A1 的构造函数被调用这是A2类的初始化顺序
父类的构造函数被调用（初始化父类）
A1中非静态变量被初始化
非静态块被执行
A1 的构造函数被调用
A2构造函数被调用这是A2类的初始化顺序（注意静态变量）
父类的构造函数被调用（初始化父类）
A1中非静态变量被初始化
非静态块被执行
A1 的构造函数被调用
A2构造函数被调用我们还注意到静态变量被A2全盘继承下来了
应该是初始化问题吧，看看，这个测试程序吧

Answer 2

int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};    
    intArray[0 ][ 0]={0,0}
      intArray[0 ][ 1]={2,3}
      intArray[1][ 1]={3,4,5} 
----------------------------------------
intArray[0][0] = 1;
intArray[0][1] = 2;
intArray[1][0] = 2;
intArray[1][1] = 3;
intArray[2][0] = 3;
intArray[2][1] = 4;
intArray[2][2] = 5;是这样的。
自己体会下吧。

Answer 3

关于第一点，说java数组不是连续有效的，是因为它分配数组不是连续分的，就是不是分配拉第一个数组后面跟着分第二个数组这样，而是第一个数组分在这里，第二个数组分在那里，他们是在不同的地方。所以java数组的可以动态 地存储数组元素。

Answer 4

String s[ ][ ] = new String[2][ ];
先指定第一维为二，s[0] = new String[3];//指定维数为三
s[1] = new String[5];//指定维数为五
然后再为第二维指定数组的个数不知道有不有说清楚。

Answer 5

第二此例子：
二维简单数据类型数组的动态初始化如下,
　　int a[ ][ ] = new int[2][ ]；
　　a[0] = new int[3];
　　a[1] = new int[5];　　对二维复合数据类型的数组，必须首先为最高维分配引用空间，然后再顺次为低维分配空间。
　　而且，必须为每个数组元素单独分配空间。
不明白的地方：为何第二个索引都没有指明，是个空的[].
第三个例子：
String s[ ][ ] = new String[2][ ];
　　s[0]= new String[2];//为最高维分配引用空间
　　s[1]= new String[2]; //为最高维分配引用空间
　　s[0][0]= new String("Good");// 为每个数组元素单独分配空间
　　s[0][1]= new String("Luck");// 为每个数组元素单独分配空间
　　s[1][0]= new String("to");// 为每个数组元素单独分配空间
　　s[1][1]= new String("You");// 为每个数组元素单独分配空间
该数组第二维没有指出索引，那如何知道是2，还付了数值
两个例子是一回事，只不过，是例二只分配空间没有赋值，例三只配空间并赋值
那就说一例三吧：
你可以把二维数组看成是一个表，
String s[ ][ ] = new String[2][ ]; 可以理解为，这个表为2行！
s[0]= new String[2];//为最高维分配引用空间 可以理解为 第一行为2列 
s[0][0]= new String("Good");// 为每个数组元素单独分配空间 可以理解为，第一行第一列为“Good” 
String s[ ][ ] = new String[2][ ];
　　s[0]= new String[2];//为最高维分配引用空间
　　s[1]= new String[2]; //为最高维分配引用空间
这几条语句相当于：String s[][] = new String[2][2];
其实例子的注释写得很明白，楼主好好体会吧！！

Answer 6

int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};    
    intArray[0 ][ 0]={0,0} 
      intArray[0 ][ 1]={2,3} 
      intArray[1][ 1]={3,4,5} 
---------------------------------------- 
intArray[0][0] = 1; 
intArray[0][1] = 2; 
intArray[1][0] = 2; 
intArray[1][1] = 3; 
intArray[2][0] = 3; 
intArray[2][1] = 4; 
intArray[2][2] = 5;是这样的。 

Answer 7

可以这样简单一点理解：java中的多维数组是一条特殊的“分散链”，如果不是最后一维，在这个位置上存储是其实是一个引用，这个引用指向它的下维（们），如果它的下维还不是最后一维的，它也会变成一个引用，再指向它的下一维，这样一直到最后一维。这样也使得Java的数组可以有无穷大，只要堆允许。
比如int iArr[][][] = new int[4][5][6];
首先，第一维是4,因为不是最后一维，所以它其实是4个引用,分别为：iArr[0],iArr[1],iArr[2],iArr[3],
因为它的下一级维数为5，所以第一维上的四个引用又每个指向5个位置，即
iArr[0]指向: iArr[0][0],iArr[0][1],iArr[0][2],iArr[0][3],iArr[0][4];
iArr[1]指向: iArr[1][0],iArr[1][1],iArr[1][2],iArr[1][3],iArr[1][4];
iArr[2]指向: iArr[2][0],iArr[2][1],iArr[2][2],iArr[2][3],iArr[2][4];
iArr[3]指向: iArr[3][0],iArr[3][1],iArr[3][2],iArr[3][3],iArr[3][4];
又因为它是一个三维数组，第二维也不是最后一维，所以第二维上所保存的东西也不是具体的值，而只是一个引用，它指向下一维的各个位置：
iArr[0][0]指向：iArr[0][0][0],iArr[0][0][1],iArr[0][0][2],iArr[0][0][3],iArr[0][0][4],iArr[0][0][5];
iArr[0][1]指向：iArr[0][1][0],iArr[0][1][1],iArr[0][1][2],iArr[0][1][3],iArr[0][1][4],iArr[0][1][5];
...
现在的像iArr[0][0][0]的引用已经是最后一维了，这些位置上才保存真正的值,其他的都只是引用
这个数组一共存了120个值。
用这种方法iArr[][][] = new int[4][5][6]定义数组在某一维上的引用个数都是一样的，而用iArr[][][] = {{{1,2,3,4},{1,2}},{{1,2}}}还可以定义出引用个数不同的数组。
具体就看你的需要了。