Java块级作用域 java代码块作用

一、代码块基础介绍

在编程过程中我们可能会遇到如下这种形式的程序：

public class Test {
    {
        
    }
}

这种形式的程序段我们将其称之为代码块，所谓代码块就是用大括号({})将多行代码封装在一起，形成一个独立的数据体，用于实现特定的算法。一般来说代码块是不能单独运行的，它必须要有运行主体。

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

二、代码块使用

• 基本语法
  [修饰符]{…};
  注意：

1. 修饰符是可选的，如果要写的话，也只能写static。
2. 代码块分为两类，使用static修饰的叫静态代码块；没有static修饰的，叫普通代码块/非静态代码块。
3. 逻辑语句可以为任何逻辑语句。
4. ;号可以写，也可以忽略。

• 代码块的好处

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

2、如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性。

三、代码块使用细节

1. static代码块(静态代码块)，作用就是对类进行初始化，它随着类的加载而执行，并且只会执行一次。但如果是普通代码块，每创建一个对象，就执行。
2. 类什么时候被加载？

• 创建对象实例时，也就是new的时候。
• 创建子类对象实例，父类也会被加载。而且父类先被加载，子类后被加载。
• 使用类的静态成员时。

3. 普通的代码块，在创建对象实例时，会隐式的被调用。被创建一次，就调用一次。如果只是使用类的静态成员的时候，普通代码块并不会执行。因为普通初始化块只有创建对象的时候才会执行，而使用静态成员只是加载类。
4. 创建一个对象时，在一个类的调用顺序是：

1. 调用静态代码块和静态属性初始化。(注：静态代码块和静态属性初始化调用的优先级一样，按顺序调用)
2. 调用普通代码块和普通属性的初始化。
3. 调用构造方法。

5. 构造方法的最前面有隐式的super();和调用普通代码块。但是静态代码块、静态属性都是在类加载时就执行完毕了。所以是优先于构造器和普通代码块执行的。
6. 静态代码块只能直接调用静态成员，普通代码块可以调用任意成员。

在Java中代码块主要分为四种：

一、 普通代码块

 普通代码块是我们用得最多的也是最普遍的，它就是在方法名后面用{}括起来的代码段。普通代码块是不能够单独存在的，它必须要紧跟在方法名后面。同时也必须要使用方法名调用它。

public class Test {
    public void test(){
        System.out.println("普通代码块");
    }
}

二、 静态代码块

想到静态我们就会想到static，静态代码块就是用static修饰的用{}括起来的代码段，它的主要目的就是对静态属性进行初始化。

public class Test {

    static{

        System.out.println("静态代码块");

    }

}

三、 同步代码块

使用 synchronized 关键字修饰，并使用“{}”括起来的代码片段，它表示同一时间只能有一个线程进入到该方法块中，是一种多线程保护机制。

四、 构造代码块

在类中直接定义没有任何修饰符、前缀、后缀的代码块即为构造代码块。我们明白一个类必须至少有一个构造函数，构造函数在生成对象时被调用。构造代码块和构造函数一样同样是在生成一个对象时被调用，那么构造代码在什么时候被调用？如何调用的呢？看如下代码：

public class Test {
    /**
     * 构造代码
     */
    {
        System.out.println("执行构造代码块...");
    }
    
    /**
     * 无参构造函数
     */
    public Test(){
        System.out.println("执行无参构造函数...");
    }
    
    /**
     * 有参构造函数
     * @param id  id
     */
    public Test(String id){
        System.out.println("执行有参构造函数...");
    }
}

上面定义了一个非常简单的类，该类包含无参构造函数、有参构造函数以及构造代码块，同时在上面也提过代码块是没有独立运行的能力，他必须要有一个可以承载的载体，那么编译器会如何来处理构造代码块呢？编译器会将代码块按照他们的顺序(假如有多个代码块)插入到所有的构造函数的最前端，这样就能保证不管调用哪个构造函数都会执行所有的构造代码块。上面代码等同于如下形式：

public class Test {
    /**
     * 无参构造函数
     */
    public Test(){
        System.out.println("执行构造代码块...");
        System.out.println("执行无参构造函数...");
    }
    
    /**
     * 有参构造函数
     * @param id  id
     */
    public Test(String id){
        System.out.println("执行构造代码块...");
        System.out.println("执行有参构造函数...");
    }
}

运行结果

public static void main(String[] args) {
        new Test();
        System.out.println("----------------");
        new Test("1");
    }
------------
Output:
执行构造代码块...
执行无参构造函数...
----------------
执行构造代码块...
执行有参构造函数...

 从上面的运行结果可以看出在new一个对象的时候总是先执行构造代码，再执行构造函数，但是有一点需要注意构造代码不是在构造函数之前运行的，它是依托构造函数执行的。正是由于构造代码块有这几个特性，所以它常用于如下场景：

 1、 初始化实例变量

如果一个类中存在若干个构造函数，这些构造函数都需要对实例变量进行初始化，如果我们直接在构造函数中实例化，必定会产生很多重复代码，繁琐和可读性差。这里我们可以充分利用构造代码块来实现。这是利用编译器会将构造代码块添加到每个构造函数中的特性。

2、 初始化实例环境

      一个对象必须在适当的场景下才能存在，如果没有适当的场景，则就需要在创建对象时创建此场景。我们可以利用构造代码块来创建此场景，尤其是该场景的创建过程较为复杂。构造代码会在构造函数之前执行。

      上面两个常用场景都充分利用构造代码块的特性，能够很好的解决在实例化对象时构造函数比较难解决的问题，利用构造代码不仅可以减少代码量，同时也是程序的可读性增强了。特别是当一个对象的创建过程比较复杂，需要实现一些复杂逻辑，这个时候如果在构造函数中实现逻辑，这是不推荐的，因为我们提倡构造函数要尽可能的简单易懂，所以我们可以使用构造代码封装这些逻辑实现部分。

四、构造器的最前面其实隐含了 super

构造器的最前面其实隐含了 super(和调用普通代码块，新写一个类演示静态相关的代码块，属性初始化，在类加载时，就执行完毕,因此是优先于构造器和普通代码块执行的

class A {
    public AO{
        super0:
        //调用普通代码块
        System.out.println("ok");
    }
}

package com.demo.codeblock_;

public class codeblock04 {
    public static void main(String[] args) {
        B b=new B();
    }
}
class AA{
    {
        System.out.println("AA的普通代码块");
    }
    public AA(){
        //1.super()
        //2.调用本类的普通代码块
        System.out.println("AA的构造器被调用");
    }
}
class B extends AA{

    {
        System.out.println("B的普通代码块");
    }
    public B(){
        //1.super()
        //2.调用本类的普通代码块
        System.out.println("B的构造器被调用");
    }
}

五、 静态代码块、构造代码块、构造函数执行顺序

从词面上我们就可以看出他们的区别。静态代码块，静态，其作用级别为类，构造代码块、构造函数，构造，其作用级别为对象。

      1、 静态代码块，它是随着类的加载而被执行，只要类被加载了就会执行，而且只会加载一次，主要用于给类进行初始化。

      2、 构造代码块，每创建一个对象时就会执行一次，且优先于构造函数，主要用于初始化不同对象共性的初始化内容和初始化实例环境。

      3、 构造函数，每创建一个对象时就会执行一次。同时构造函数是给特定对象进行初始化，而构造代码是给所有对象进行初始化，作用区域不同。

      通过上面的分析，他们三者的执行顺序应该为：

父类静态代码块 > 子类静态代码块 > main()方法 > 父类代码块 > 父类构造器 > 子类代码块 > 子类构造器

public class Test {
    /**
     * 静态代码块
     */
    static{
        System.out.println("执行静态代码块...");
    }
    
    /**
     * 构造代码块
     */
    {
        System.out.println("执行构造代码块...");
    }
    
    /**
     * 无参构造函数
     */
    public Test(){
        System.out.println("执行无参构造函数...");
    }
    
    /**
     * 有参构造函数
     * @param id
     */
    public Test(String id){
        System.out.println("执行有参构造函数...");
    }
    
    public static void main(String[] args) {
        System.out.println("----------------------");
        new Test();
        System.out.println("----------------------");
        new Test("1");
    }
}
-----------
Output:
执行静态代码块...
----------------------
执行构造代码块...
执行无参构造函数...
----------------------
执行构造代码块...
执行有参构造函数...

六、同步代码块

同步代码块指的是被Java中Synchronized关键词修饰的代码块，在Java中，Synchronized关键词不仅仅可以用来修饰代码块，与此同时也可以用来修饰方法，是一种线程同步机制，被Synchronized关键词修饰的代码块会被加上内置锁。
5.1 代码示例

public class Test4 implements Runnable {
    @Override
    public void run() {
        synchronized (CodeBlock.class) {
            System.out.print("同步代码块...");
        }
    }
 
    public static void main(String[] args) {
        CodeBlock a = new CodeBlock();
        CodeBlock b = new CodeBlock();
        new Thread(a).start();
        new Thread(b).start();
    }
}