Java 中的代码块

1. 普通代码块

方法中的代码块。

2. 构造代码块

构造块会在创建对象时被调用，每次创建都会被调用，优先于类构造函数执行。

3. 静态代码块

用 static{} 包裹起来的代码片段，只会执行一次。静态代码块优先于构造代码块执行。

4. 同步代码块

使用 synchronized(){} 包裹起来的代码块，在多线程环境下，对共享数据的读写操作是需要互斥进行的，否则会导致数据的不一致性。同步代码块需要写在方法中。

代码块的执行顺序

1.继承的代码执行顺序

示例代码:

public class Test1 {
    public static void main(String[] args) {
        B b1 = new B();
        System.out.println("再new一个");
        B b2 = new B();
    }
}
class A {
    static {
        System.out.println("class A static block ");
    }
    {
        System.out.println("class A regular block ");
    }
    public A() {
        System.out.println("class A constructor block ");
    }
}
class B extends A {
    static {
        System.out.println("class B static block ");
    }
    {
        System.out.println("class B regular block ");
    }
    public B() {
        System.out.println("class B constructor block ");
    }
}

运行结果：

class A static block 
class B static block 
class A regular block 
class A constructor block 
class B regular block 
class B constructor block 
再new一个
class A regular block 
class A constructor block 
class B regular block 
class B constructor block

结论:

 1.父类中的静态代码块  1次
 2.子类中的静态代码块  1次
 3.父类中的构造代码块  每new一次都执行
 4.父类中的构造方法  每new一次都执行
 5.子类中的构造代码块  每new一次都执行
 6.子类中的构造方法  每new一次都执行

2.内部类的代码执行顺序

示例代码：

public class Test2 {
    public static void main(String[] args) {
        //分别单独运行以下3条
        OuterClass outerClass=new OuterClass();
        OuterClass.StaticInnerClass staticInnerClass=new OuterClass.StaticInnerClass();
        OuterClass.InnerClass innerClass=new OuterClass().new InnerClass();
    }
}
class OuterClass {
    static {
        System.out.println("class OuterClass static block ");
    }
    {
        System.out.println("class OuterClass regular block ");
    }
    public OuterClass() {
        System.out.println("class OuterClass constructor block ");
    }
    static class StaticInnerClass {
        static {
            System.out.println("class StaticInnerClass static block ");
        }
        {
            System.out.println("class StaticInnerClass regular block ");
        }
        public StaticInnerClass() {
            System.out.println("class StaticInnerClass constructor block ");
        }
    }
    class InnerClass {
        {
            System.out.println("class InnerClass regular block ");
        }
        public InnerClass() {
            System.out.println("class InnerClass constructor block ");
        }
    }
}

OuterClass outerClass=new OuterClass(); 运行结果：

class OuterClass static block 
class OuterClass regular block 
class OuterClass constructor block

OuterClass.StaticInnerClass staticInnerClass=new OuterClass.StaticInnerClass();运行结果：

class StaticInnerClass static block 
class StaticInnerClass regular block 
class StaticInnerClass constructor block

OuterClass.InnerClass innerClass=new OuterClass().new InnerClass();运行结果：

class OuterClass static block 
class OuterClass regular block 
class OuterClass constructor block 
class InnerClass regular block 
class InnerClass constructor block

结论：

 1.静态内部类中才允许使用静态代码块
 2.内部类编译之后，会形成独立的.class文件
 3.仅仅实例化外部类对象时，仅仅将外部类加载进内存，内部类暂时不加载
 4.在实例化静态内部类对象时，仅仅执行内部类的代码块，外部类代码块不执行
 5.在实例化非静态内部类对象时，先把外部类的代码块和构造器执行完毕后再执行内部类的代码块和构造器