代码块02使用细节-Java

aPurpleBerry

已于 2023-11-27 14:41:42 修改

阅读量796

点赞数 19

分类专栏： Java SE 文章标签： java

于 2023-11-27 11:51:24 首次发布

本文链接：https://blog.csdn.net/yavlgloss/article/details/134640498

版权

Java SE 专栏收录该内容

64 篇文章 0 订阅

订阅专栏

代码块02使用细节

四、使用细节

四、使用细节

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