1 /*
2 看程序写结果：
3 A:访问成员变量的原则：就近原则。
4 B:this和super的问题：
5 this 访问本类的成员
6 super 访问父类的成员(可以理解为的)
7 C:子类的所有构造方法执行前默认先执行父类的无参构造方法。
8 D:一个类的初始化过程：
9 成员变量进行初始化过程如下：
10 默认初始化
11 显示初始化
12 构造方法初始化
13
14 输出的结果是：
15 fu
16 zi
17 30
18 20
19 10
20 */
21 class Fu {
22 public int num = 10;
23 public Fu() {
24 System.out.println("fu");
25 }
26 }
27
28 class Zi extends Fu {
29 public int num = 20;
30 public Zi() {
31 System.out.println("zi");
32 }
33 public void show() {
34 int num = 30;
35 System.out.println(num); //30
36 System.out.println(this.num); //20
37 System.out.println(super.num); //10
38 }
39 }
40 class ExtendsTest {
41 public static void main(String[] args) {
42 Zi z = new Zi();
43 z.show();
44 }
45 }
1 /*
2 看程序写结果：
3 A:一个类的静态代码块,构造代码块,构造方法的执行流程：
4 静态代码块 > 构造代码块 > 构造方法
5 B:静态的内容是随着类的加载而加载，
6 即：静态代码块的内容会优先执行。
7 C:构造代码块
8 在类中方法外出现(即在类中的成员位置)，可以把多个构造方法方法中相同的代码存放到一起，用于对对象进行初始化，
9 每次调用构造方法都执行，并且在构造方法前执行。
10 C:子类的所有的构造方法默认都会去访问父类的无参构造方法。
11
12 输出结果是：
13 静态代码块Fu
14 静态代码块Zi
15 构造代码块Fu
16 构造方法Fu
17 构造代码块Zi
18 构造方法Zi
19 */
20 class Fu {
21 static {
22 System.out.println("静态代码块Fu");
23 }
24
25 {
26 System.out.println("构造代码块Fu");
27 }
28
29 public Fu() {
30 System.out.println("构造方法Fu");
31 }
32 }
33
34 class Zi extends Fu {
35 static {
36 System.out.println("静态代码块Zi");
37 }
38
39 {
40 System.out.println("构造代码块Zi");
41 }
42
43 public Zi() {
44 System.out.println("构造方法Zi");
45 }
46 }
47
48 class ExtendsTest2 {
49 public static void main(String[] args) {
50 Zi z = new Zi();
51 }
52 }
1 /*
2 看程序写结果：
3 A:成员变量的问题
4 int x = 10; //成员变量x是基本类型
5 Student s = new Student(); //成员变量s是引用类型
6 B:一个类的初始化过程
7 先进行成员变量的初始化：
8 默认初始化
9 显示初始化
10 构造方法初始化
11 C:子父类的初始化(分层初始化)
12 先进行父类初始化，然后进行子类初始化。
13
14 结果：
15 YXYZ
16
17 问题：
18 虽然子类中的构造方法默认有一个 super();
19 但初始化的时候，不是按照那个顺序进行的。
20 而是按照分层初始化进行的。
21 super(); 它仅仅表示要先初始化父类数据，再初始化子类数据。
22 */
23
24 class X {
25 //成员变量(引用类型)
26 Y b = new Y();
27 //无参构造方法
28 X() {
29 System.out.print("X");
30 }
31 }
32
33 class Y {
34 //无参构造方法
35 Y() {
36 System.out.print("Y");
37 }
38 }
39
40 public class Z extends X {
41 //成员变量(引用类型)
42 Y y = new Y();
43 //无参构造方法
44 Z() {
45 //super(); //它仅仅表示要先初始化父类数据，再初始化子类数据。
46 System.out.print("Z");
47 }
48 public static void main(String[] args) {
49 new Z();
50 }
51 }
