代码块的使用细节

1. 无论我们调用那个构造器，都会优先调用方法块中的属性，然后在调用你调用的那个构造器
2. 代码块就相当于是另一种形式的构造器（也就是对构造器的补充），可以做到初始化的作用

---

1. 按理说每创建一个相同对象的时候都会执行一次代码块，但是静态代码块比较特殊，当静态代码块被执行过一次之后，那么下次在创建对象的时候就不会在继续执行该态代码块了

   public class staticClass {
       public static void main(String[] args) {
   //        这里创建了两个 A 类的对象
   //        当一个类中有一个静态代码块和一个普通代码块时，则会优先执行静态代码块
   //        但是静态代码块只被执行了一次
   //        而普通代码块则被执行了两次
           new A();
           new A();
       }
   }
   
   class A {
       {
           System.out.println("A类普通代码块被执行。。。");
       }
       static {
           System.out.println("A类静态代码块被执行。。。");
       }
   }

   // 运行结果
   A类静态代码块被执行。。。
   A类普通代码块被执行。。。
   A类普通代码块被执行。。。

2. 因为当我们调用子类时，则会优先调用子类中的构造器，而构造器中又默认的有 super 关键字，所以调用子类的构造器时则会优先调用父类中的构造器，在调用构造器之前会优先调用代码块，所以当我们调用子类时则会优先调用父类中的代码块，其次在调用父类中的构造器，然后在调用子类中的代码块，最后在调用子类中的构造器，这样以此类推

3. 调用静态成员（静态方法和静态变量）时，普通代码块不会被调用，但是静态代码块会被调用

   public class staticClass {
       public static void main(String[] args) {
           A.info();
       }
   }
   
   class A {
       public static void info() {
           System.out.println("info被调用。。。");
       }
       static {
           System.out.println("静态代码块被调用。。。");
       }
       {
           System.out.println("普通代码块被调用。。。");
       }
   }

   // 运行结果
   静态代码块被调用。。。
   info被调用。。。

   如果调用的是普通成员，那么静态成员和普通成员都会被调用，因为调用普通成员首先要创建对象，而创建对象则会调用静态成员

   public class staticClass {
       public static void main(String[] args) {
           System.out.println("a = " + new A().a);
       }
   }
   
   class A {
       int a;
       static {
           System.out.println("静态代码块被调用");
       }
       {
           a = 10;
           System.out.println("普通代码块");
       }
       public A() {
   //        在运行构造器之前会先调用普通代码块
           System.out.println("都创建对象了，构造器怎么可能不会被调用?");
       }
   }

   // 运行结果
   静态代码块被调用
   普通代码块
   都创建对象了，构造器怎么可能不会被调用
   a = 10

4. 静态代码块和静态属性是同一级的，普通代码块和普通属性也是同一级的

5. 静态的优先级要高于普通的优先级

6. 在一个类中，有一个普通代码块和一个普通属性，因为它们的运行优先级是一样的，所以运行的顺序就是从上往下运行，静态的也是一样的

7. 运行顺序就是在一个类中先从上往下运行静态代码（静态代码块和静态属性初始化），然后在从上往下运行普通代码（普通代码块和普通属性初始化），最后在运行构造器

8. 调用构造器时会优先调用 super(); 调用完之后在执行普通代码块

9. 静态代码块只能调用静态的方法和属性，普通代码块则可以调用任意的方法和属性

10. 在继承中，先调用父类中的静态代码，在调用子类中的静态代码；然后在调用父类中的普通代码（普通代码块、普通属性初始化），在调用父类中的构造器；最后在调用子类中的普通代码块（普通代码块、普通属性初始化），在调用子类中的构造器；在同级的代码中则是按从上往下的顺序运行

public class staticClass {
 public static void main(String[] args) {
     B b = new B();
 }
}

class A {
 int a = Return();
 public int Return() {
     System.out.println("父类的普通方法被调用");
     return 10;
 }
 {
     System.out.println("父类中的普通代码块被调用");
 }
 static {
     System.out.println("父类中的静态代码块被调用");
 }
 public A() {
     // super();
     // 调用普通代码块
     System.out.println("父类中的构造器被调用");
 }
}

class B extends A {
 int a = Return1();
 public int Return1() {
     System.out.println("子类的普通方法被调用");
     return 20;
 }
 {
     System.out.println("子类中的普通代码块被调用");
 }
 static {
     System.out.println("子类中的静态代码块被调用");
 }
 public B() {
     System.out.println("子类中的构造器被调用");
 }
}

// 运行结果
父类中的静态代码块被调用
子类中的静态代码块被调用
父类的普通方法被调用
父类中的普通代码块被调用
父类中的构造器被调用
子类的普通方法被调用
子类中的构造器被调用