四、使用细节

1、static代码块/静态代码块，随着类的加载而执行，且只执行一次

static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。

如果是普通代码块，每创建一个对象，就执行。

2、 类什么时候被加载 [重要 ! ]

① 创建对象实例时(new)
② 创建子类对象实例，父类也会被加载
③ 使用类的静态成员时（静态属性，静态方法）

案例演示：static代码块

① 创建对象实例时(new)

public class CodeBlockDetail01 {public static void main(String[] args) {A aa = new A();}
}class A {static {System.out.println("AA的静态代码块");}
}

② 创建子类对象实例，父类也会被加载

public class CodeBlockDetail01 {public static void main(String[] args) {B b = new B();}
}class A {static {System.out.println("父类A的静态代码块");}
}class B extends A {static {System.out.println("子类B的静态代码块");}
}

③ 使用类的静态成员时（静态属性，静态方法）
使用静态属性或者静态方法的时候，类已经加载

public class CodeBlockDetail01 {public static void main(String[] args) {//③ 使用类的静态成员时（静态属性，静态方法）System.out.println(Cat.n1);}
}
class Cat {public static int n1 = 999;static {System.out.println("cat 的静态代码块");}
}

static代码块/静态代码块，随着类的加载而执行，且只执行一次

public class CodeBlockDetail01 {public static void main(String[] args) {D d = new D();D d1 = new D();}
}
class D {static{System.out.println("DD的静态代码块");}
}

3、普通代码块，在创建对象实例时，会被隐式的调用。

普通代码块，在创建对象实例时，会被隐式的调用。每创建一次，就会调用一次。
如果只是使用类的静态成员时，普通代码块并不会执行。

案例演示：普通代码块

① 普通代码块，被创建一次，就会调用一次。

	//【main】D d = new D();D d1 = new D();class D {static{System.out.println("D的static静态代码块");}{System.out.println("D的普通代码块");}}

② 只是使用类的静态成员时，普通代码块并不会执行。
注意：静态代码块一定会执行。

	//【main】System.out.println(D.n2);class D {public static int n2 = 8888;static{System.out.println("D的static静态代码块");}{System.out.println("D的普通代码块");}}

4、创建一个对象时，在一个类调用顺序是

创建 一个对象 时，在 一个类 调用顺序是 (重点，难点)∶

① 调用静态代码块 和 静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）

② 调用普通代码块 和 普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用）

补充：这里暗含了顺序，①中的静态代码块和静态属性初始化 一定比②的早调用。

③ 调用构造方法。

案例演示

① 静态代码块和静态属性初始化调用的优先级一样，按照定义的顺序调用。

//【main】
A a = new A();class AA {//静态属性初始化private static int n1 = getN1();//静态代码块static {System.out.println("A的静态代码块0101");}public static int getN1() {System.out.println("getN1()被调用");return 100;}
}

修改代码顺序为：

class AA {//静态代码块static {System.out.println("A的静态代码块0101");}//静态属性初始化private static int n1 = getN1();public static int getN1() {System.out.println("getN1()被调用");return 100;}
}

② 普通属性初始化 & 普通代码块

class AA {//普通属性private int n2 = getN2();//普通代码块{System.out.println("普通代码块0101");}public int getN2() {System.out.println("getN22()被调用");return 200;}
}

5、构造器的最前面其实隐含了super()和调用普通代码块

构造器的最前面其实隐含了super()和调用普通代码块。
静态相关的代码块、属性初始化，在类加载时，就已经执行完毕。
因此是优先于构造器和普通代码块执行的。

class A {public A() {// 构造器//这里有隐藏的执行要求// (1) super() // (2) 调用普通代码块System.out.println("A的构造器");}
}

案例演示

CodeBlockDetail03.java

//【main】
BBB bbb = new BBB();class AAA {{System.out.println("AAA的普通代码块···");}public AAA() {// 构造器//这里有隐藏的执行要求// (1) super() - AAA 的父类是Object// (2) 调用普通代码块System.out.println("AAA的构造器···");}
}class BBB extends AAA{{System.out.println("BBB的普通代码块···");}public BBB() {// 构造器//这里有隐藏的执行要求// (1) super()// (2) 调用普通代码块System.out.println("BBB的构造器···");}
}

6、创建一个子类时(继承关系)，调用顺序

创建一个子类时(继承关系)，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：

//面试题
A（子类）->B（父类）
① 父类的静态代码块和静态属性（优先级一样，按定义顺序执行）
② 子类的静态代码块和静态属性（优先级一样，按定义顺序执行）
····································注意此时类加载完成································
③ 父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
④ 父类的构造方法
⑤ 子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
⑥ 子类的构造方法

以 class B02 extends A02 为例。
【分析】new B02();
(1) 进行类的加载
1.1 先加载 父类 A02 。1.2 再加载 B02
-加载子类的时候，一定要有父类，（比如先加载Object类）
-加载的时候，进行静态属性初始化 & 静态代码块
（静态属性初始化 & 静态代码块与类加载相关，优先级一样，取决于代码顺序）
(2) 创建对象
2.1 从子类的构造器开始
子类构造器隐藏了①super()②普通代码块 & 普通属性相关···

案例演示

CodeBlockDetail04.java

7、静态代码块只能直接调用静态成员(静态属性和静态方法)

静态代码块只能直接调用静态成员( 静态属性和静态方法 )，普通代码块可以调用任意成员。

本笔记是对韩顺平老师的Java课程做出的梳理。方便本人和观看者进行复习。
课程请见： https://www.bilibili.com/video/BV1fh411y7R8/?spm_id_from=333.999.0.0&vd_source=ceab44fb5c1365a19cb488ab650bab03