【学习笔记】Java代码块

一、代码块概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

• 普通代码块
• 构造代码块
• 静态代码块
• 同步代码块（后续多线程部分）

二、普通代码块

普通代码块和构造代码块的区别是，构造代码块是在类中定义的，而普通代码块是在方法体中定义的。且普通代码块的执行顺序和书写顺序一致。

public void sayHello(){
    {
        System.out.println("普通代码块");
    }
}

---

定义：

普通代码块：定义在方法中的代码块，用法较少见。
作用：管理局部变量的生命周期，当代码块执行完毕后，及时释放掉局部变量的内存空间。

public class NormalCodeBlock {
    // 普通代码块/局部代码块
    // 1. 方法内部
    // 2. 它是一个代码块{}
    // 3. 作用：管理局部变量的生命周期，当代码块执行完毕后，及时释放掉局部变量的内存空间
    public static void main(String[] args) {
        // 代码块
        {
            int a = 1;  // 本处的 a 为局部变量
            System.out.println(a);
        }
        int a = 2;
        System.out.println(a);
        // 代码块
        {
            System.out.println(a);
        }
    }
    

// 执行结果
    1
    2
    2

三、构造代码块

构造代码块

①、格式

在Java类中使用{}声明的代码块（和静态代码块的区别是少了static关键字）:

public class CodeBlock {
    static{
        System.out.println("静态代码块");
    }
    {
        System.out.println("构造代码块");
    }
}

②、执行时机

构造代码块在创建对象时被调用，每次创建对象都会调用一次，但是优先于构造函数执行。需要注意的是，听名字我们就知道，构造代码块不是优先于构造函数执行，而是依托于构造函数，也就是说，如果你不实例化对象，构造代码块是不会执行的。怎么理解呢？我们看看下面这段代码：

public class CodeBlock {
    {
        System.out.println("构造代码块");
    }
     
    public CodeBlock(){
        System.out.println("无参构造函数");
    }
    public CodeBlock(String str){
        System.out.println("有参构造函数");
    }
}

反编译生成的class文件：

import java.io.PrintStream;

public class CodeBlock
{
  static
  {
    System.out.println("静态代码块");
  }
  
  public CodeBlock()
  {
    System.out.println("构造代码块");
    System.out.println("无参构造函数");
  }
  
  public CodeBlock(String s)
  {
    System.out.println("构造代码块");
    System.out.println("有参构造函数");
  }
  
  public void show()
  {
    System.out.println("普通代码块");
  }
}

如果存在多个构造代码块，则执行顺序按照书写顺序依次执行。

③、构造代码块的作用

和构造函数的作用类似，都能对对象进行初始化，并且只要创建一个对象，构造代码块都会执行一次。但是反过来，构造函数则不一定每个对象建立时都执行（多个构造函数情况下，建立对象时传入的参数不同则初始化使用对应的构造函数）。

利用每次创建对象的时候都会提前调用一次构造代码块特性，我们可以做诸如统计创建对象的次数等功能。

---

构造代码块是在创建对象时被调用的代码块，每次创建对象时都会执行，且其执行优先级高于构造函数。 构造代码块的主要作用是对所有对象进行统一的初始化操作。与构造函数不同，构造函数是为每个对象实例进行初始化，而构造代码块则是对所有对象进行公共的初始化操作。这种结构可以用于执行一些不需要针对每个对象实例单独处理的操作，例如统计对象的创建次数等。此外，构造代码块的执行顺序优先于构造函数，这意味着在构造函数执行之前，构造代码块已经完成其操作。‌

---

定义：

构造代码块：定义在类中的代码块(不加修饰符)。也叫：实例代码块、非静态代码块。构造代码块一般用于初始化实例成员变量。

// 构造代码块
// 定义在类中的{}
// 会在构造函数执行之前被执行
public class Person {
    String name;
    int age;
    String species;

    // 构造代码块
    {
        species = "人类";
        System.out.println("这是一个构造代码块~");
    }

    public Person(){
        System.out.println("无参构造方法执行");
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public static void main(String[] args) {
    Person p = new Person();
    System.out.println(p.species);
}

// 输出结果
这是一个构造代码块~
无参构造方法执行
人类

构造函数

1.构造函数的命名必须和类名完全相同。在Java中普通函数可以和构造函数同名，但是必须带有返回值；

2.构造函数的功能主要用于在类的对象创建时定义初始化的状态。它没有返回值，也不能用void来修饰。这就保证了它不仅什么也不用自动返回，而且根本不能有任何选择。而其他方法都有返回值，即使是void返回值。尽管方法体本身不会自动返回什么，但仍然可以让它返回一些东西，而这些东西可能是不安全的；

3.构造函数不能被直接调用，必须通过new运算符在创建对象时才会自动调用；而一般的方法是在程序执行到它的时候被调用的；

4.当定义一个类的时候，通常情况下都会显示该类的构造函数，并在函数中指定初始化的工作也可省略，不过Java编译器会提供一个默认的构造函数.此默认构造函数是不带参数的。而一般的方法不存在这一特点；

四、静态代码块

①、格式

在Java类中（方法中不能存在静态代码块）使用static关键字和{}声明的代码块：

public class CodeBlock {
    static {
        System.out.println("静态代码块");
    }
}

②、执行时机

静态代码块在类被加载的时候就运行了，而且只运行一次，并且优先于各种代码块以及构造函数。如果一个类中有多个静态代码块，会按照书写顺序依次执行。后面在比较的时候会通过具体实例来证明。

③、静态代码块的作用

一般情况下，如果有些代码需要在项目启动的时候就执行，这时候就需要静态代码块。比如一个项目启动需要加载的很多配置文件等资源，我们就可以都放入静态代码块中。

④、静态代码块不能存在任何方法体中

这个应该很好理解，首先我们要明确静态代码块是在类加载的时候就要运行了。我们分情况讨论：

对于普通方法，由于普通方法是通过加载类，然后new出实例化对象，通过对象才能运行这个方法，而静态代码块只需要加载类之后就能运行了。

对于静态方法，在类加载的时候，静态方法也已经加载了，但是我们必须要通过类名或者对象名才能访问，也就是说相比于静态代码块，静态代码块是主动运行的，而静态方法是被动运行的。

不管是哪种方法，我们需要明确静态代码块的存在在类加载的时候就自动运行了，而放在不管是普通方法还是静态方法中，都是不能自动运行的。

⑤、静态代码块不能访问普通变量

这个理解思维同上，普通变量只能通过对象来调用，是不能放在静态代码块中的。

---

定义

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

静态代码块（static code block） 是在类被加载时执行的一段代码，它在类的生命周期中只会执行一次。静态代码块使用关键字 “static” 声明，并被包含在类的声明中。

静态代码块常用于在类加载时进行一些初始化操作，例如初始化静态变量或执行静态方法。它们的执行顺序是在类被加载时自上而下执行。

示例：

public class StaticCodeBlockDemo {
    // 静态代码块
    static {
        System.out.println("静态代码块被执行");
        // 执行其他初始化操作...
    }
    public static void main(String[] args) {
    System.out.println("main()方法被执行");
    // 调用其他方法...
	}
}

输出：

静态代码块被执行
main()方法被执行

静态代码块在类加载时首先被执行，然后才是 main() 方法。这意味着静态代码块可以在类加载之前进行一些必要的初始化工作。

注意： 静态代码块只会执行一次，即使类被实例化多次，静态代码块也只会在类加载时执行一次。静态代码块不管生成多少个对象，其只会执行一次，因为类只会加载一次。

五、执行顺序

静态代码块 > 构造代码块 > 构造函数 > 普通代码块

示例：

public class CodeBlock {
    static {
        System.out.println("静态代码块");
    }
    {
        System.out.println("构造代码块");
    }
    public CodeBlock(){
        System.out.println("无参构造函数");
    }
    public void show(){
        {
            System.out.println("普通代码块");
        }
    }
    
    public static void main(String[] args) {
        System.out.println("main() 方法被执行");
        CodeBlock c1 = new CodeBlock();
        c1.show();
        System.out.println("--------- 分割线 ---------");
        CodeBlock c2 = new CodeBlock();
        c2.show();
    }
}

输出：

静态代码块
main() 方法被执行
构造代码块
无参构造函数
普通代码块
--------- 分割线 ---------
构造代码块
无参构造函数
普通代码块

创建了两个对象，但是静态代码块只是调用了一次。

六、父类和子类执行顺序

父类静态代码块 > 子类静态代码块 > 父类构造代码块 > 父类构造函数 > 子类构造代码块 > 子类构造函数

对象的初始化顺序：

首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有构造代码块，如果有就执行父类的构造代码块，父类的构造代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有构造代码块，如果有就执行子类的构造代码块。子类的构造代码块执行完毕再去执行子类的构造方法。

总之一句话，静态代码块内容先执行，接着执行父类构造代码块和构造方法，然后执行子类构造代码块和构造方法。（父类早于子类、静态早于非静态、非静态早于构造函数）

(1) 加载父类（以下序号相同，表明初始化是按代码从上到下的顺序来的）
	1. 为父类的静态属性分配空间并赋于初值
 	1. 执行父类静态初始化块
(2) 加载子类
	2. 为子类的静态属性分配空间并赋于初值
	2. 执行子类静态初始化块
(3) 加载父类构造器
	3. 初始化父类的非静态属性并赋于初值
	3. 执行父类的非静态代码块
	4. 执行父类的构造方法
(4)加载子类构造器
	5. 初始化子类的非静态属性并赋于初值
	5. 执行子类的非静态代码块
	6. 执行子类的构造方法

示例：

// 父类
public class SuperClass {
    static {
        System.out.println("父类静态代码块");
    }
    {
        System.out.println("父类构造代码块");
    }
    public SuperClass(){
        System.out.println("父类构造函数");
    }
}
// 子类
public class SubClass extends SuperClass {
    static {
        System.out.println("子类静态代码块");
    }
    {
        System.out.println("子类构造代码块");
    }
    public SubClass(){
        System.out.println("子类构造函数");
    }
}

// 测试类
public class ExtendsTest {
    public static void main(String[] args) {
        System.out.println("main() 方法被执行");
        SubClass sub1 = new SubClass();
        System.out.println("------------ 分割线 ------------");
        SubClass sub2 = new SubClass();
    }
}

输出：

main() 方法被执行
父类静态代码块
子类静态代码块
父类构造代码块
父类构造函数
子类构造代码块
子类构造函数
------------ 分割线 ------------
父类构造代码块
父类构造函数
子类构造代码块
子类构造函数

参考内容
…
…

---