第七章：复用类（下）

继承与初始化

首先看代码（摘自java编程思想）：

class Insect {
private int i = 9;
protected int j;

Insect() {
System.out.println("i = " + i + ", j = " + j);
j = 39;
}

private static int x1 = printInit("static Insect.x1 initialized");

static int printInit(String s) {
System.out.println(s);
return 47;
}
}

public class Beetle extends Insect {
private int k = printInit("Beetle.k initialized");

public Beetle() {
System.out.println("k = " + k);
System.out.println("j = " + j);
}

private static int x2 = printInit("static Beetle.x2 initialized");

public static void main(String[] args) {
System.out.println("Beetle constructor");
Beetle b = new Beetle();
}

}

// 运行结果
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9, j = 0
Beetle.k initialized
k = 47
j = 39

解释：请大家仔细看代码，我们的主类是 Beetle 类，main方法是写在 Beetle 类中的，所以当刚执行 main() 的时候 Beetle 类被加载（加载器首先启动并找出子类的编译代码（子类名.class文件中）），对子类进行加载的过程中发现 Beetle 类还有一个父类（通过extends得知），于是继续进行加载，不管你是否想产生一个父类的对象，父类对象的加载都会发生。静态初始化是在类初次加载时被执行的，所以静态属性先执行了，又因为父类的静态必须先于子类的静态。因为子类的静态初始化可能会依赖于父类的成员能否被正确初始化。 所以输出了：

static Insect.x1 initialized
static Beetle.x2 initialized

至此，类就加载完毕了。就可以创建对象了。然后代码继续执行输出

Beetle constructor

然后就会执行 Beetle b = new Beetle(); 首先，对象中的基本类型被会被设为默认值，对象引用被设为null—这是通过将对象内存设置为二进制零值而一举生成的。然后父类的构造器会被调用（因为 Beetle 类的构造函数又默认调用了父类的构造函数，所以先执行父类的构造函数），在执行构造函数的时候，构造函数会将变量赋值。所以输出：

i = 9, j = 0

然后调用子类的构造方法，又输出：

Beetle.k initialized
k = 47
j = 39

再看一段代码，会引起我们混淆的代码：

public class Test1 {
public static void main(String args[]) {
new Son();
}
}

class Father {
private int a = 10;

public Father() {
System.out.println(a);
a = 11;
this.dis();
}

public void dis() {
System.out.println("fu类" + a);
}
}

class Son extends Father {
private int a = 110;

public Son() {
a = 222;
}

public void dis() {
System.out.println("子类" + a);
}
}

// 输出结果
10
子类0

为什么说会引起混淆呢？因为父类的构造函数里调用了一个子类重写的方法，而你在main方法里又new 的是子类，所以父类构造方法里调用的是子类的dis()方法，此时子类的a还没有被赋值，只是被初始化为了0.所以才会是这种输出结果。

总结：

加载类

对象中的基本类型被设为默认值，对象引用被设为null

调用了构造方法，为变量赋了值

…