继承，构造器，初始化顺序

期中考试考了这个 题目 ：居然 是Thinking in Java 的一个 例子。。，，看看 例子的 前面 和 后面的，我才 发现：我就这个 例子 没 有 去看 ，感觉 真亏了 ，12分就这忽略中失去！！

class Insect {
  private int i = 9;
  protected int j;
  Insect() {
    print("i = " + i + ", j = " + j);
    j = 39;
  }
  private static int x1 =
    printInit("static Insect.x1 initialized");
  static int printInit(String s) {
    print(s);
    return 47;
  }
}

public class Beetle extends Insect {
  private int k = printInit("Beetle.k initialized");
  public Beetle() {
    print("k = " + k);
    print("j = " + j);
  }
  private static int x2 =
    printInit("static Beetle.x2 initialized");
  public static void main(String[] args) {
    print("Beetle constructor");
    Beetle b = new Beetle();
  }
} /* Output:
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9, j = 0
Beetle.k initialized
k = 47
j = 39
*///:~

终结一下：
[list]
[*]程序怎么进行的 ？在Beetle上运行java 时，所发生的第一件事就是试图访问Beetle.main()(一个static方法)，于是加载器开始启动并找出Beetle类的编译代码，
编译器注意到它有个基类（注意这是由extends引起的），于是加载基类，直到无基类。
[*]
[*]
[*]接下，从跟基类开始初始化static，直到最下面的导出类。why 从跟基类到导出类，
因为导出类的static初始化可能会以来与基类成员能否正确的初始化。
到这，必要的类加载完，可以开始创建对象了。
[*]
[*]开始初始化对象，首先对象中的所有基本类型都会被设为默认值，对象的引用设为null（通过将对象内存设为二进制零值而一举生成）。
[*]
[*]然后基类的构造器的调用(为什么开始就 调用基类？在导出类中必须确定基类中所有成员都是有效的)
[/list]


构造器初始化的顺序学习：

class Meal {
  Meal() { print("Meal()"); }
}

class Bread {
  Bread() { print("Bread()"); }
}

class Cheese {
  Cheese() { print("Cheese()"); }
}

class Lettuce {
  Lettuce() { print("Lettuce()"); }
}

class Lunch extends Meal {
  Lunch() { print("Lunch()"); }
}

class PortableLunch extends Lunch {
  PortableLunch() { print("PortableLunch()");}
}

public class Sandwich extends PortableLunch {
  private Bread b = new Bread();
  private Cheese c = new Cheese();
  private Lettuce l = new Lettuce();
  public Sandwich() { print("Sandwich()"); }
  public static void main(String[] args) {
    new Sandwich();
  }
} /* Output:
Meal()
Lunch()
PortableLunch()
Bread()
Cheese()
Lettuce()
Sandwich()
*///:~

总结调用顺序1：

// 1.调用基类的构造器，首先是跟基类，然后是下一层导出类，直到（基类中）最底层的导出类
// 2.俺声明顺序调用成员的初始化方法。
// 3.调用导出类构造器的主体。

修改上面代码段 ：对class Lunch 修改如下：

class Lunch extends Meal {
	public int initialA() {
		print("A is initialized");
		return 1;
	}

	int A = initialA();
	Meal a = new Meal();

	Lunch() {
		print("Lunch()");
	}

	Meal d = new Meal();
	// 似乎从上面加入的代码可以看出，在加载构造器时，
        //先按顺序调用成员的初始化方法。再调用构造器的主体。
}

进一步总结调用顺序2：
// 1.调用基类的构造器，首先是跟基类，然后是下一层导出类，直到（基类中）最底层的导出类。

// 2.俺声明顺序调用成员的初始化方法。

// 3.调用导出类构造器的主体。

// 说明 ：第二和第三步同样的适用（于第一步中）基类的构造器的调用。