一：基本介绍

代码化块又称为初始化块,属于类中的成员[即是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通 { } 包围起来。
但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，__而是加载类时，或创建对象时隐式调用。

二：基本语法

  1. [修饰符] {
  2.     代码;
  3. }
  1. 修饰符可选，也只能写static
  2. 代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块
  3. 逻辑语句可以分为任何逻辑语句（输入，输出，方法调用，循环，判断）
  4. ；可以写上，也可以忽略。

    三：代码快的优点

  • 相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作

  • 场景:__如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

    1. public class block {
    2.   public static void main(String[] args) {
    3.       Movie sakura = new Movie("sakura");
    4.       Movie sakura1 = new Movie("sakura",180);
    5.       Movie sakura2 = new Movie("sakura",200,5);
    6.   }
    7. }
    8. class Movie {
    9.   private String name;
    10.   private int money;
    11.   private int num;
    12.   {
    13.       System.out.println("电影票购买成功");
    14.   }
    15.   public Movie(String name) {
    16.       this.name = name;
    17.   }
    18.   public Movie(String name, int money) {
    19.       this.name = name;
    20.       this.money = money;
    21.   }
    22.   public Movie(String name, int money, int num) {
    23.       this.name = name;
    24.       this.money = money;
    25.       this.num = num;
    26.   }
    27. }

    四：代码块的注意事项和细节

  • static代码块也叫静态代码块，作用就是对类进行初始化

    • 它随着类的加载而执行，并且只会执行一次。（因为类只会加载一次）

    • 如果是普通代码块，每创建一个对象，就执行。 ```java public class StaticBlock { public static void main(String[] args) { AA aa = new AA(); AA aa1 = new AA(); //不管创建多少个对象，静态代码块只会执行一次 } } class AA {

      static { System.out.println(“AA中的静态代码块执行”); } }

  2. - **_类什么时候被加载_**
  3.    - **_①创建对象实例时(new)_**
  4.    - **_②创建子类对象实例，父类也会被加载_**
  5.    - **_③使用类的静态成员时(静态属性,静态方法)_**
  6. ```java
  7. package Date0807.Test01;
  9. /**
  10.  * 作者：sakura
  11.  * 日期：2022年08月07日 10:38
  12.  */
  13. public class StaticBlock {
  15.     public static void main(String[] args) {
  17.         //实例化一个对象的时候
  18.         //AA aa = new AA();
  19.         System.out.println("---------");
  20.         //创建一个子类对象时，父类也会被加载，且先被加载
  21.         //BB bb = new BB();
  22.         System.out.println("---------");
  23.         //使用类的静态属性，方法时，类被加载
  24.         System.out.println(BB.a);
  26.     }
  27. }
  28. class AA {
  30.     static {
  31.         System.out.println("AA中的静态代码块执行");
  32.     }
  33. }
  34. class BB extends AA{
  35.     static int a = 100;
  36.     static {
  37.         System.out.println("BB中的静态代码块执行");
  38.     }
  39. }
  • 普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。
    • 如果只是使用类的静态成员时，普通代码块并不会执行。（类加载和普通代码块没有关系） ```java

public class StaticBlock {

  1. public static void main(String[] args) {
  2.     //静态代码块只会执行一次，普通代码块每创建一个对象执行一次
  3.     AA aa = new AA();
  4.     AA aa1 = new AA();
  5. }

} class AA { //静态代码块 static { System.out.println(“AA中的静态代码块执行”); } //普通代码快 { System.out.println(“AA的普通代码块”); } }

  1. :::danger
  2. 可以简单理解：普通代码块是构造器的补充，构造器调用，它才会调用。
  3. :::
  5. - **_创建一个对象时，在一个类调用顺序是:(重点，难点):_**
  6.    - **_①调用静态代码块和静态属性初始化(注意:静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)_**
  7. ```java
  8. public class saticdetail {
  9.     public static void main(String[] args) {
  10.         AA aa = new AA();
  11.     }
  12. }
  13. class  AA{
  14.     //静态属性初始化和静态代码块优先级一样，所以按照顺序调用
  15.     private static int n = getN();
  17.     static {
  18.         System.out.println("AA中的static代码块");
  19.     }
  20.     public static int getN() {
  21.         System.out.println("getN()执行");
  22.         return n;
  23.     }
  24. }

  • ②调用普通代码块和普通属性的初始化(注意:普通代码块和普通属性初始化调用的优先级一样,如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)

    1. public class saticdetail {
    2. public static void main(String[] args) {
    3.    AA aa = new AA();
    4. }
    5. }
    6. class  AA{
    7. private  int n = getN();
    8. {
    9.    System.out.println("AA中的普通代码块");
    10. }
    11. public  int getN() {
    12.    System.out.println("getN()执行");
    13.    return n;
    14. }
    15. }

  • ③调用构造方法/构造器

    1. //将上面这些完成之后，最后才会调构造器
    2. public AA() {
    3. System.out.println("构造器调用");
    4. }

    :::danger 静态>普通>构造器 :::

  • 构造器的最前面其实隐含了super( )和调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕

    • 因此是优先于构造器和普通代码块执行的
      1. public class saticdetail {
      2. public static void main(String[] args) {
      3.    new BB();
      4. }
      5. }
      6. class  AA{
      7. {
      8.    System.out.println("AA普通代码块");
      9. }
      10. public AA() {
      11.    //这里面有隐藏的代码
      12.    //1:super()
      13.    //2:调用本类的普通代码块
      14.    System.out.println("AA构造器");
      15. }
      16. }
      17. class BB extends AA{
      18. {
      19.    System.out.println("BB普通代码块");
      20. }
      21. public BB() {
      22.    //这里面有隐藏的代码
      23.    //1:super()
      24.    //2:调用本类的普通代码块
      25.    System.out.println("BB构造器");
      26. }
      27. }

  • 我们看一下创建一个子类对象时(继承关系)，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下:

    • ①父类的静态代码块和静态属性(优先级一样，按定义顺序执行)
    • ②子类的静态代码块和静态属性(优先级一样，按定义顺序执行)
    • ③父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
    • ④父类的构造方法
    • ⑤子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)

    • ⑥子类的构造方法/面试题 ```java //在主类中new B02(); 输出顺序 class A02 { //父类 private static int n1 = getVal01();

      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 { // private static int n3 = getVal03();

  1. static { 
  2.     System.out.println("B02 的一个静态代码块..");//(4)
  3. } 
  5. public int n5 = getVal04(); 
  6. {
  7.     System.out.println("B02 的第一个普通代码块..");//(9)
  9. } 
  11. public static int getVal03() { 
  12.     System.out.println("getVal03");//(3) 
  13.     return 10;
  14. }
  16. public int getVal04() { 
  17.     System.out.println("getVal04");//(8) 
  18.     return 10;
  19. } //一定要慢慢的去品.. 
  20. public B02() {  //构造器 
  21.     //隐藏了super() 
  22.     //普通代码块和普通属性的初始化... 
  23.     System.out.println("B02 的构造器");//(10) // TODOAuto-generated constructor stub
  24. }

}

  1. <a name="GKbcm"></a>
  2. ### 五：练习
  3. <a name="OA2Ns"></a>
  4. #### 1：
  5. ```java
  6. class Person { 
  7.     public static int total;//静态变量
  8.     static {//静态代码块 
  9.         total = 100; 
  10.         System.out.println("in static block!");//(1)
  11.     }
  12. }
  14. public class Test { 
  15.     public static void main(String[] args) { 
  16.         System.out.println("total = "+ Person.total); //100 
  17.         System.out.println("total = "+ Person.total); //100
  18.     }
  19. }

2：

  1. class Sample {
  2.     Sample(String s) {
  3.         System.out.println(s);
  4.     }
  5.     Sample() {
  6.         System.out.println("Sample 默认构造函数被调用"); 
  7.     }
  8. }
  10. class Test {
  11.     Sample sam1 = new Sample("sam1 成员初始化");//
  12.     static Sample sam = new Sample("静态成员 sam初始化 ");//
  14.     static {
  15.         System.out.println("static 块执行");//
  16.         if (sam == null) System.out.println("sam is null");
  17.     }
  18.     Test(){
  19.         System.out.println("Test默认构造器函数被调用");
  20.     }
  21. }
  23. public static void main(String str[]) { 
  24.     Test a=new Test();//无参构造器
  25. }
  1. 静态成员 sam初始化
    2. static 块执行
    3. sam1 成员初始化
    4. Test 默认构造函数被调用