在Java语言中初次使用自定义类的数组时，参照C++中的自定义类数组，编写了如下代码

    1. public class Test {
    2.     public static void main(String[] args) {
    3.         Person[] persons = new Person[3];
    5.         persons[0].name = "Rookiegan";
    6.         persons[0].age = 22;
    8.         for(Person p : persons) {
    9.             System.out.println("name:" + p.name);
    10.             System.out.println("age: " + p.age);
    11.         }
    12.     }
    13.     static class Person {
    14.         String name;
    15.         int age;
    16.     }
    17. }

    从C++的逻辑来看，这段代码似乎没有问题，编译也顺利通过，但在执行的时候在persons[0].name = “Rookiegan”;这一句抛出空指针异常，也就是说persons[0]根本没有指向一段真正的内存空间。于是我为Person类添加了自定义的构造函数，输出打印信息。

    1. Person() {
    2.     System.out.println("Person Constructor");
    3. }

    测试发现现象与不加一样，这个构造函数根本没有执行。

    查阅资料发现，由于Java中引用变量存储在栈中，而真正的对象存储在堆中，Person[] persons = new Person[3];这个语句根本不会为数组的成员分配内存，只是在栈中定义一个Person[]类的引用，该引用会执向3个Person类的对象。

    将程序进行如下更改，编译通过，且执行正常。

    1. public class Test {
    2.     public static void main(String[] args) {
    3.         Person[] persons = new Person[3];
    5.         // 如不使用用以下三行代码，执行到persons[0].name = "Rookiegan"时会报空指针异常
    6.         persons[0] = new Person();
    7.         persons[1] = new Person();
    8.         persons[2] = new Person();
    10.         persons[0].name = "Rookiegan";
    11.         persons[0].age = 22;
    13.         for(Person p : persons) {
    14.             System.out.println("name:" + p.name);
    15.             System.out.println("age: " + p.age);
    16.         }
    18.     }
    19.     static class Person {
    20.         String name;
    21.         int age;
    23.         Person() {
    24.             System.out.println("Person Constructor");
    25.         }
    26.     }
    27. }