今天1024，咱来聊一下 Java 中的静态代码块与构造代码块 ~

梦里梦外; 2023-10-09 15:02 14阅读 0赞

> 今天1024，咱们过节，给大伙们送上短文一份~

#### 文章目录 ####

*   *  静态代码块
     *   *  是什么
         *  怎么用
     *  构造代码块
     *   *  是什么
         *  怎么用
     *  继承的影响

### 静态代码块 ###

#### 是什么 ####

**作用**：初始化必须在项目启动时执行的代码；

**运行时机**：在类被加载（类初始化阶段）的时候运行，而且只运行一次；

**执行优先级**：优先于各种代码块以及构造函数；

*  同类中的多个静态代码块，就会按照书写的顺序执行；

#### 怎么用 ####

比如说加载数据库连接池配置：

public class JDBCUtils {
        
    	 private static DataSource ds ;
         // 静态代码块
         static{
        
            try {
        
                // 加载配置文件
                Properties pro = new Properties();
                pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
                // 	获取DataSource
                ds = DruidDataSourceFactory.createDataSource(pro);
            } catch (IOException e) {
        
                e.printStackTrace();
            } catch (Exception e) {
        
                e.printStackTrace();
            }
    }

### 构造代码块 ###

#### 是什么 ####

**构造代码块（也叫非静态代码块）**：在每个对象生成时都会被执行一次，可以初始化类的实例变量；

**运行时机**：静态代码块 < 构造代码块 < *构造函数主体代码执行之前被运行*；

“构造函数主体代码执行之前被运行” 这句话怎么理解呢？

我们来看一段代码：

public class DemoTest {
        
        private String str;
        
        static{
        
            System.out.println("静态代码块");
        }
    
        {
        
            System.out.println("构造代码块（非静态代码块）");
        }
    
        public DemoTest() {
        
            System.out.println("无参构造");
        }
    
        public DemoTest(String str) {
        
            this.str = str;
            System.out.println("有参构造");
        }
    
        public static void main(String[] args) {
        
            DemoTest demoTest = new DemoTest();
        }
    }

运行 main 方法结果：  
![在这里插入图片描述][6058dc89b65e487f8f7411cc15238d3e.png_pic_center]

反编译查看一波，从图中就可以很好的体现：“构造函数主体代码执行之前被运行” 这句话，构造代码块中的代码在编译时被插入到了构造函数主体代码之前：  
![在这里插入图片描述][de9dc3dc02914278b6df415bb20616fd.png_pic_center]

#### 怎么用 ####

上述反编译后示例中就是很好的体现：

public class DemoTest {
        
        {
        
           System.out.println("构造代码块（非静态代码块）");
        }
    }

### 继承的影响 ###

想一想，类与类之间的继承关系，对代码块会有什么影响呢？

/**
     * 父类
     */
    public class DemoTest {
        
        private String str;
    
        static{
        
            System.out.println("静态代码块");
        }
    
        {
        
            System.out.println("构造代码块（非静态代码块）");
        }
    
        public DemoTest() {
        
            System.out.println("无参构造");
        }
    
        public DemoTest(String str) {
        
            this.str = str;
            System.out.println("有参构造");
        }
    
        public static void main(String[] args) {
        
            System.out.println("main方法");
            new DemoSub();
        }
    }
    
    /**
     * 子类
     */
    public class DemoSub extends DemoTest{
        
        private String strSub;
    
        static{
        
            System.out.println("sub-静态代码块");
        }
    
        {
        
            System.out.println("sub-构造代码块（非静态代码块）");
        }
    
        public DemoSub() {
        
            System.out.println("sub-无参构造");
        }
    
        public DemoSub(String strSub) {
        
            this.strSub = strSub;
            System.out.println("sub-有参构造");
        }
    
        public static void main(String[] args) {
        
            System.out.println("sub-main方法");
            new DemoSub();
        }
    }

`DemoSub` 子类 main 方法运行结果：  
![在这里插入图片描述][0363fcf327614c68bc8685a5989141c9.png_pic_center]  
从上图可以看出，继承后的输出顺序为：

1.  父类 - 静态代码块；
2.  子类 - 静态代码块；
3.  子类 - main方法；
4.  父类 - 构造代码块（非静态代码块）；
5.  父类 - 无参构造；
6.  子类 - 构造代码块（非静态代码块）；
7.  子类 - 无参构造；

`DemoTest` 父类 main 方法运行结果：  
![在这里插入图片描述][27b1463775c3495a891579df59036692.png_pic_center]

从上图可以看出，继承后的输出顺序为：

1.  父类 - 静态代码块；
2.  父类 - main方法；
3.  子类 - 静态代码块；
4.  父类 - 构造代码块（非静态代码块）；
5.  父类 - 无参构造；
6.  子类 - 构造代码块（非静态代码块）；
7.  子类 - 无参构造；

这里需要注意：

*  父类中 main 方法在运行时会执行一次 `父类 - 静态代码块` ；
 *  main 方法中，创建子类，子类继承父类，按`DemoSub` 子类 main() 方法运行结果，父方法中的静态代码块理应再执行一次，但是输出结果中并没有打印两次 `父类 - 静态代码块` ；

这也说明了：静态代码块在类被加载（类初始化阶段）的时候运行，而且只运行一次；

以上需要注意，两个类中的 main 方法输出结果均是创建 `DemoSub` 子类。

--------------------

![a564d02ed5f5414ca28ba15bfeec1c67.png][] 感 谢 各 位 大 佬 的 阅 读，随 手 点 赞，日 薪 过 万~！ ！！

[6058dc89b65e487f8f7411cc15238d3e.png_pic_center]: https://img-blog.csdnimg.cn/6058dc89b65e487f8f7411cc15238d3e.png#pic_center
[de9dc3dc02914278b6df415bb20616fd.png_pic_center]: https://img-blog.csdnimg.cn/de9dc3dc02914278b6df415bb20616fd.png#pic_center
[0363fcf327614c68bc8685a5989141c9.png_pic_center]: https://img-blog.csdnimg.cn/0363fcf327614c68bc8685a5989141c9.png#pic_center
[27b1463775c3495a891579df59036692.png_pic_center]: https://img-blog.csdnimg.cn/27b1463775c3495a891579df59036692.png#pic_center
[a564d02ed5f5414ca28ba15bfeec1c67.png]: https://img-blog.csdnimg.cn/a564d02ed5f5414ca28ba15bfeec1c67.png