代码块02使用细节
- 四、使用细节
- 1、static代码块/静态代码块，随着类的加载而执行，且只执行一次
- 2、 类什么时候被加载 [重要 ! ]
- 案例演示：static代码块
- 3、普通代码块，在创建对象实例时，会被隐式的调用。
- 案例演示：普通代码块
- 4、创建一个对象时，在一个类调用顺序是
- 案例演示
- 5、构造器的最前面其实隐含了super()和调用普通代码块
- 案例演示
- 6、创建一个子类时(继承关系)，调用顺序
- 案例演示
- 7、静态代码块只能直接调用静态成员(静态属性和静态方法)
四、使用细节
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
