期中考试考了这个 题目 :居然 是Thinking in Java 的一个 例子。。,,看看 例子的 前面 和 后面的,我才 发现:我就这个 例子 没 有 去看 ,感觉 真亏了 ,12分就这忽略中失去!!
终结一下:
[list]
[*]程序怎么进行的 ?在Beetle上运行java 时,所发生的第一件事就是试图访问Beetle.main()(一个static方法),于是加载器开始启动并找出Beetle类的编译代码,
编译器注意到它有个基类(注意这是由extends引起的),于是加载基类,直到无基类。
[*]
[*]
[*]接下,从跟基类开始初始化static,直到最下面的导出类。why 从跟基类到导出类,
因为导出类的static初始化可能会以来与基类成员能否正确的初始化。
到这,必要的类加载完,可以开始创建对象了。
[*]
[*]开始初始化对象,首先对象中的所有基本类型都会被设为默认值,对象的引用设为null(通过将对象内存设为二进制零值而一举生成)。
[*]
[*]然后基类的构造器的调用(为什么开始就 调用基类?在导出类中必须确定基类中所有成员都是有效的)
[/list]
构造器初始化的顺序学习:
总结调用顺序1:
// 1.调用基类的构造器,首先是跟基类,然后是下一层导出类,直到(基类中)最底层的导出类
// 2.俺声明顺序调用成员的初始化方法。
// 3.调用导出类构造器的主体。
修改上面代码段 :对class Lunch 修改如下:
进一步总结调用顺序2:
// 1.调用基类的构造器,首先是跟基类,然后是下一层导出类,直到(基类中)最底层的导出类。
// 2.俺声明顺序调用成员的初始化方法。
// 3.调用导出类构造器的主体。
// 说明 :第二和第三步同样的适用(于第一步中)基类的构造器的调用。
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.调用导出类构造器的主体。
// 说明 :第二和第三步同样的适用(于第一步中)基类的构造器的调用。