第一题

/*

看程序写结果：

A:成员变量就近原则

B:this和super的问题

this访问本类的成员

super访问父类的成员

C:子类构造方法执行前默认先执行父类的无参构造方法

D:一个类的初始化过程

成员变量进行初始化

默认初始化

显示初始化

构造方法初始化     用参数去调用构造函数就是显式初始化，没有参数就是默认初始化，表现为直接声明对象和数组

所以执行父类无参构造方法前会先执行成员变量的初始化，public int num = 10;，再执行无参构造方法，同理，执行完父类无参构造方法，再执行子类成员变量的初始化，public int num = 20;最后执行子类构造方法。

结果：

fu

zi

30

20

10

*/

class Fu{

public int num = 10;//public int num;这是第一步，不赋值，默认为0，称为默认初始化；第二步，把10赋予给num，这一步称为显式初始化，每个成员变量赋值都会在jvm的堆内存执行                                 //这样的两个步骤。

public Fu(){

System.out.println("fu");

}

}

class Zi extends Fu{

public int num = 20;

public Zi(){

System.out.println("zi");

}

public void show(){

int num = 30;

System.out.println(num); //30

System.out.println(this.num); //20

System.out.println(super.num); //10

}

}

class ExtendsTest {

public static void main(String[] args) {

Zi z = new Zi();

z.show();

}

}

题目2

/*

看程序写结果：

A:一个类的静态代码块,构造代码块,构造方法的执行流程

静态代码块 > 构造代码块 > 构造方法

B:静态的内容是随着类的加载而加载

静态代码块的内容会优先执行

C:子类初始化之前先会进行父类的初始化

结果是：

静态代码块Fu

静态代码块Zi

构造代码块Fu

构造方法Fu

构造代码块Zi

构造方法Zi

*/

class Fu {

static {

System.out.println("静态代码块Fu");

}

{

System.out.println("构造代码块Fu");

}

public Fu() {

System.out.println("构造方法Fu");

}

}

class Zi extends Fu {

static {

System.out.println("静态代码块Zi");

}

{

System.out.println("构造代码块Zi");

}

public Zi() {

System.out.println("构造方法Zi");

}

}

class ExtendsTest2 {

public static void main(String[] args) {

Zi z = new Zi();

}

}

问题三

/*

看程序写结果：

A:成员变量的问题

int x = 10; //成员变量是基本类型

Student s = new Student(); //成员变量是引用类型

B:一个类的初始化过程

成员变量的初始化

默认初始化

显示初始化

构造方法初始化

C:子父类的初始化(分层初始化)

先进行父类初始化，然后进行子类初始化。

结果：

YXYZ

问题：

虽然子类中构造方法默认有一个super()

初始化的时候，不是按照那个顺序进行的。

而是按照分层初始化进行的。

它仅仅表示要先初始化父类数据，再初始化子类数据。

*/

class X {

Y b = new Y();

X() {

System.out.print("X");

}

}

class Y {

Y() {

System.out.print("Y");

}

}

public class Z extends X {

Y y = new Y();

Z() {

//super();

System.out.print("Z");

}

public static void main(String[] args) {

new Z();

}

}