Java中的代码块

比眉伴天荒 2024-04-26 10:45 14阅读 0赞

## 代码块 ##

### 1. 代码块基本概念 ###

*  **代码块：又称为初始化块，属于类中的成员【即是类的一部分】，类似于方法，将逻辑语句封装在方法体中，用 \{\} 包围起来。**
 *  **基本用法：**  
    ![在这里插入图片描述][5bf640b47bd0431293f869b1f05cff69.png]
 *  **代码块的理解：**

> **（1）相当于另外一种形式的构造器（是对构造器的补充机制），可以做初始化操作；**  
> **（2）使用场景，如果多个构造器中都有重复的语句，可以抽取到代码块中，提高代码的复用性，相当于对构造器的重载；**  
> **（3）代码块调用的顺序优先于构造器。**

### 二、代码块使用注意事项和细节 ###

*  **注意事项：**

**1. 类什么时候被加载**

> **（1）创建类的对象实例时（new），类会被加载。**  
> **（2）存在继承关系，当创建子类对象实例时，其所有上级父类也会被加载；并且父类先被加载，越上级的父类，越先被加载。**  
> **（3）当使用类的静态成员时（静态属性，静态方法），类会被加载。**  
> **（4）注意，类的加载是在内存的方法区中。**

**2. 什么是代码块**

> **（1）static 关键字修饰的代码块也叫静态代码块，它的作用就是对类进行初始化；它伴随着类的加载而执行，并且只会执行一次。**  
> **（2）没有关键字修饰的代码块也叫普通代码块，它相当于是构造器的补充机制；每当我们创建一个类的对象时，普通代码块就会被调用一次；如果只是直接使用类的静态成员，没有创建对象，它不会被调用；注意，普通代码块的调用与类的加载没有关系。**

**3. 创建一个对象时，在一个类中各属性和方法被虚拟机调用的顺序**

> **（1）首先是调用静态代码块和进行静态属性初始化 （注意，调用静态代码块和静态属性初始化的优先级一样，若有多个静态代码块和静态属性初始化同时存在，则按他们定义的顺序使用），这一步是在类的加载时进行的。**  
> **（2）其次是正式在堆内存中创建一个对象空间，并调用普通代码块和进行普通属性的初始化 （注意，调用普通代码块和普通属性初始化的优先级一样，若有多个普通代码块和普通属性初始化同时存在，则按他们定义的顺序使用）。**  
> **（3）最后是调用类中的构造方法。**  
> **（4）补充：对于普通的静态方法，不会被虚拟机自动执行，啥时候被调用，啥时候执行。**

*  **代码举例说明：**

public class CodeBlockDetail02 {
        
        public static void main(String[] args) {
        
    
            A a = new A();// 输出如下：
            // (1) A 静态代码块01 (2) getN1被调用...
            // (3) A 普通代码块01 (4) getN2被调用...
            // (5) A() 构造器被调用
        }
    }
    
    class A {
        
    
    	// 普通代码块
        {
         
            System.out.println("A 普通代码块01");
        }
    
        // 普通属性的初始化
        private int n2 = getN2();
    
        // 静态代码块
        static {
         
            System.out.println("A 静态代码块01");
        }
    
        // 静态属性的初始化
        private static int n1 = getN1();
    
        // 静态方法
        public static int getN1() {
        
            System.out.println("getN1被调用...");
            return 100;
        }
    
        // 普通方法/非静态方法
        public int getN2() {
         
            System.out.println("getN2被调用...");
            return 200;
        }
    
        // 无参构造器
        public A() {
        
            System.out.println("A() 构造器被调用");
        }
    }

**4. 存在继承关系时，调用普通代码块和普通属性初始化的说明**

> **（1）在构造器/构造方法的最前面其实隐含了 super（）语句，还有调用普通代码块和普通属性的初始化的语句，最后才是构造器自己的语句。**  
> **（2）我们这里所说的普通属性的初始化，指的是属性在默认初始化后进行的，在构造器内的初始化（这一部分的概念是在面对对象基础部分学习的）。**

*  **代码举例说明：**

public class CodeBlockDetail03 {
        
        public static void main(String[] args) {
        
            new BBB();
            //(1) AAA的普通代码块 (2) AAA() 构造器被调用
            //(3) BBB的普通代码块 (4) BBB() 构造器被调用
        }
    }
    
    // 父类
    class AAA {
         
    
        // 普通代码块
        {
        
            System.out.println("AAA的普通代码块");
        }
    
        // 构造器
        public AAA() {
        
            //(1) super()
            //(2) 调用本类的普通代码块和普通属性的初始化
            System.out.println("AAA() 构造器被调用....");
        }
    }
    
    // 子类
    class BBB extends AAA  {
        
    
        // 普通代码块
        {
        
            System.out.println("BBB的普通代码块...");
        }
    
        public BBB() {
        
            // (1)super()
            // (2)调用本类的普通代码块和普通属性的初始化
            System.out.println("BBB() 构造器被调用....");
        }
    }

**5. 存在继承关系时，创建一个子类对象，各个方法和属性被虚拟机调用的顺序**

>  *  **首先是在类加载时，调用静态代码块和静态属性的初始化。**  
>     **（1）父类的静态代码块和静态属性（优先级一样，按定义顺序执行）。**  
>     **（2）子类的静态代码块和静态属性（优先级一样，按定义顺序执行）。**
>  *  **其次是在堆内存中创建对象空间，调用普通代码块和普通属性的初始化，调用构造方法。**  
>     **（3）在构造器中调用父类的普通代码块和普通属性的初始化（优先级一样，按定义顺序执行）。**  
>     **（4）执行父类的构造器其余的方法。**  
>     **（5）在构造器中调用子类的普通代码块和普通属性的初始化（优先级一样，按定义顺序执行）。**  
>     **（6）执行子类的构造器其余的方法。**

*  **代码举例说明：**

public class CodeBlockDetail04 {
        
        public static void main(String[] args) {
        
            // 说明
            // (1) 进行类的加载
            //   1.1 先加载 父类 A02 ;1.2 再加载子类 B02
            // (2) 创建对象空间
            //   2.1 从子类的构造器开始
            new B02();// 创建对象
        }
    }
    
    //父类
    class A02 {
         
    	
        static {
        
            System.out.println("A02的一个静态代码块..");//(2)
        }
    
        {
        
            System.out.println("A02的第一个普通代码块..");//(5)
        }
    
        public int n3 = getVal02();//普通属性的初始化
    
        public static int getVal01() {
        
            System.out.println("getVal01");//(1)
            return 10;
        }
    
        public int getVal02() {
        
            System.out.println("getVal02");//(6)
            return 10;
        }
    
    	//构造器
        public A02() {
        
            //隐藏
            //super()
            //普通代码和普通属性的初始化
            System.out.println("A02的构造器");//(7)
        }
    
    }
    
    //子类
    class B02 extends A02 {
         //
        
        static {
        
            System.out.println("B02的一个静态代码块..");//(4)
        }
    
        public int n5 = getVal04();
    
        {
        
            System.out.println("B02的第一个普通代码块..");//(9)
        }
    
        public static int getVal03() {
        
            System.out.println("getVal03");//(3)
            return 10;
        }
    
        public int getVal04() {
        
            System.out.println("getVal04");//(8)
            return 10;
        }
        
        // 构造器
        public B02() {
        
            //隐藏了
            //super()
            //普通代码块和普通属性的初始化
            System.out.println("B02的构造器");//(10)
        }
    }

## 总结 ##

*  本文是小白博主在学习B站韩顺平老师的Java网课时整理总结的学习笔记，在这里感谢韩顺平老师的网课，如有有兴趣的小伙伴也可以去看看。
 *  本文详细解释了代码块的概念与使用，并深入解释了创建一个对象时的底层流程分析，非常非常重要，希望小伙伴们看后能有所收获！
 *  最后，如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！我们下一篇博文见吧！

[5bf640b47bd0431293f869b1f05cff69.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/d6940f4a277c48bc8fb1e8f6bb496907.png