接着上篇博客，我提到了如何用静态代码块来进行static成员变量初始化
那么这篇文章我会给大家介绍一下代码块到底是个什么块（hhh）

1.🍟代码块概念以及分类

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

  • 普通代码块
  • 构造（实例）代码块
  • 静态代码块
  • 同步代码块（涉及到多线程部分的知识，后面再解释）

    2.🌍普通代码块

    普通代码块：定义在方法中的代码块
    首先我们看下面这一段代码
    1. /**
    2. * Created with IntelliJ IDEA.
    3. * Description: Hello,I would appreciate your comments~
    4. * User:
    5. * Date: -04-03
    6. * Destination:普通块代码块
    7. */
    8. public class TestDemo1 {
    9.   public static void main(String[] args) {
    10.       {//普通代码块直接用{}定义，
    11.           int x =10;
    12.           System.out.println("x1 = "+x);
    13.       }
    14.       int x = 200;
    15.       System.out.println("x2 = "+x);
    16.       {
    17.           int y = 300;
    18.           System.out.println("y = "+y);
    19.       }
    20.   }
    21. }
    这里的输出为：

    x1 = 10 x2 = 200 y = 300

我们可以发现这里的执行顺序就是按照正常从上往下的。
但是，我们把这里的第二个代码块中的y换成x试一试

  1. public class TestDemo1 {
  2.     public static void main(String[] args) {
  3.         {//普通代码块直接用{}定义，
  4.             int x =10;
  5.             System.out.println("x1 = "+x);
  6.         }
  7.         int x = 200;
  8.         System.out.println("x2 = "+x);
  9.         {
  10.             int x = 300;
  11.             System.out.println("x = "+x);
  12.         }
  13.     }
  14. }

image.png
我们发现就会报错，所以同一个方法中的不同普通代码块还是有联系的

3.🍰构造（实例）代码块

构造块：定义在类中的代码块（不加修饰）。也叫：实例代码块。
构造代码块一般用于初始化实例成员变量

  1. /**
  2.  * Created with IntelliJ IDEA.
  3.  * Description: Hello,I would appreciate your comments~
  4.  * User:
  5.  * Date: -04-03
  6.  * Destination:实例代码块
  7.  */
  8. public class Student {
  9.     private String name;
  10.     private String gender;
  11.     private int age;
  12.     private double score;
  14. //    构造函数
  15.     public Student(){
  16.         System.out.println("Student的构造函数被执行了！");
  17.     }
  19. //    实例代码块
  20.     {
  21.         this.name = "Bonnie";
  22.         this.age = 19;
  23.         this.gender = "女";
  24.         System.out.println("实例代码块初始化了！");
  25.     }
  27.     public void show(){
  28.         System.out.println("name:"+name+"age:"+age+"gender:"+gender);
  29.     }
  32.     public static void main(String[] args) {
  33.         Student s1 = new Student();
  34.         s1.show();
  35.     }
  36. }

输出结果如下👇
image.png
实例代码块，通过字面意思我们就可以知道它是我们在实例化对象的时候才会去调用的代码块
⚡[注意事项]
实例代码块一般都是优先于构造方法执行的。因为编译完成之后，编译器会将实例代码块中的代码拷贝到每个构造方法第一条语句前。
我们从字节码角度来看，其实就是拷贝一下实例代码块到构造方法之前。
实例代码块一般用来初始化实例出的对象的普通的成员变量

4.🍦静态代码块

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

  1. public class Student {
  2.     private String name;
  3.     private String gender;
  4.     private int age;
  5.     private double score;
  6.     private static String classRoom;
  8. //    构造函数
  9.     public Student(){
  10.         System.out.println("Student的构造函数被执行了！");
  11.     }
  13. //    实例代码块
  14.     {
  15.         this.name = "Bonnie";
  16.         this.age = 19;
  17.         this.gender = "女";
  18.         System.out.println("实例代码块初始化了！");
  19.     }
  21. //    静态代码块
  22.     static {
  23.         classRoom = "三年二班";
  24.         System.out.println("静态代码块被调用了！");
  25.     }
  27.     public static void main(String[] args) {
  28.         Student s1 = new Student();
  29.         Student s2 = new Student();
  30.         System.out.println(Student.classRoom);
  31.     }
  32. }

输出结果如下👇
image.png
我们可以看到，静态代码块是优先于其他而执行的，而且整个过程中只执行一次
[注意事项]

  • 静态代码块和实例化的对象没有关系,在整个程序中只会执行一次
  • 静态成员变量是类的属性,所以是在JVM加载类的时候开辟空间并同时初始化的
  • Java代码在讲过编译器编译之后,如果要运行必须要先经过类加载子系统加载到JVM中再能运行

image.png
在链接阶段第二步准备中会给静态成员变量开辟空间,并设置为默认值,在初始化阶段,会执行静态代码块中的代码.

  • 如果一个类中包含多个静态代码块,在编译代码的时候,编译器会按照定义的先后次序依次进行合并,最终放在生成的<>方法中,该方法在类加载时调用,并且只调用一次
  • 实例代码块只有在创建对象的时候才会执行

代码块就到这里咯,希望能帮到你~
感谢阅读!