1.代码块相当于另外一种形式的构造器（对构造器的一种补充机制），可以做初始化操作
2.应用场景：如果多个构造器都有重复的语句，可以抽取到初始化块中，提高代码的重用性
例如：看电影会有广告

class Movie{
 private String name;
 private double price;
 private String director;{
 System.out.println(“电影屏幕打开！”);
 System.out.println(“广告开始了！”);
 System.out.println(“电影开始了”);
 }
 public Movie(String name){
 this.name = name;
 }
 public Movie(String name;double price){
 this.name = name;
 this.price = price;
 }
 public Movie(String name;double price;String director){
 this.name = name;
 this.price = price;
 this.director = director;
 }
 }

细节：
一.static代码块也叫静态代码块，作用就是对类进行初始化，而且它随类的加载而执行，并且只会执行一次.如果是普通代码块，每创建一个对象，就执行
二.类什么时候被加载？
创建对象实例时（new）静态代码块会被执行
创建子类对象实例，父类也会被加载 先执行父类的静态代码块
使用类的静态成员时（静态属性，静态方法）都会被调用 因为会执行属性所在的类会被执行，所以它类中的代码块会被执行
三.普通的代码块创建一次执行一次，每创建对象就会被调用一次，隐式调用
小结：
1.static代码块是类加载，执行，只会执行一次
2.普通代码块是创建对象时调用，创建一次调用一次
3.类加载的3种情况，需要记牢

四：创建一个对象时，在一个类调用的顺序
1.先调用静态的代码块和静态属性初始化，在调用它们时是按照先后顺序的
2.再调用普通代码块和普通属性初始化，也是按照先后顺序
3.最后是调用构造方法

五：构造器在调用时如果有继承那它就会先调用父类的构造器 有一个隐式的super()和一个调用代码块，
就是说如果类中有代码块，在调用构造器时会先执行代码块，如果继承父类就看父类中有没有代码块，它是先调用代码块在执行构造器的。
实例演示：

class A{
 public A() {
 //在这个位置是有一个隐式的执行要求的
 //super();
 //调用代码块
 System.out.println(“你牛逼！真不错！”);
 }
 }


这里就考验对继承的理解了！要把之前的理清楚！
再看一个实例的代码：

public class CodeBlock_02 {

public static void main(String[] args) {
        
    new B();


}

}

class A {

{
    System.out.println("A 的 代码块！");
}


public A () {
    System.out.println("我是A的无参构造器！");
}

}

class B extends A {

{
    System.out.println("B 的 代码块！");
}


public B () {
    //代码块的优先级高于构造器
    //在执行此构造器时它会默认去执行它的父类构造器 super();
    //然后再调用它的普通代码块
    System.out.println("我是B的无参构造器！");


}

}
记住：代码块的优先级大于构造器
六：当创建一个继承类 使用它的构造器时 它的调用顺序是：
1.先执行父类的静态代码块和静态属性初始化 （这两个优先级一样，看顺序）
2.再执行子类的静态代码块和静态属性初始化（优先级一样，也是看顺序）
3.父类的普通代码块和普通属性初始化 （优先级也是一样，看顺序）
4.然后是父类的构造器
5.子类的普通代码块和普通属性初始化（优先级一样，顺序）
6.子类的构造器
代码演示：

public static void main(String[] args) {
 new Test_02();
 }}
class Test_01 {
 private static int n1 = getA();
 static {
 System.out.println(“01 的静态代码块！”);//2
 }
{
    System.out.println("01 的普通方法！");//5
}
private int n2 = getB();
public Test_01 () {


    System.out.println("01 的构造器");//7
}


public static int  getA() {//1
    System.out.println("getA的静态方法！");
    return 10;
}
public int getB () {
    System.out.println("getB 的普通方法！");//6
    return 29;
}

}

class Test_02 extends Test_01 {
 static {
 System.out.println(“02 的静态代码块！”);//3
 }
 private static int N1 = getAA();
 private int N2 = getBB();
 {
 System.out.println(“02 的普通代码块！”);//9
 }
 public int getBB () {
 System.out.println(“getBB 的普通方法！”);//8
 return 30;
 }
 public static int getAA() {
 System.out.println(“getAA 的静态方法！”);//4
 return 111;
 }
 public Test_02 () {
 //super();//代码块执行
 System.out.println(“02的构造器！”);//10
 }
 }


七：静态代码块只能调用静态属性和静态方法 ，普通代码块可以调用所以成员属性和方法
这个太简单就不代码演示了
还是简单说一下：
就是在静态的代码块中只能使用或者调用静态的属性或者方法，而在普通代码块中则可以调用任意的参数成员！