Java 代码块详解

注:本文出自博主 Chloneda:个人博客 | 博客园 | Github | Gitee | 知乎

注:本文原链接:https://www.cnblogs.com/chloneda/p/java-code-block.html

前言

Java系列,尽量采用通俗易懂、循序渐进的方式,让大家真正理解Java基础知识!

代码块分类

在Java中,使用{}括起来的代码被称为代码块(Code block),根据其位置和声明的不同,可以分为:

  • 局部代码块。
  • 构造代码块。
  • 同步代码块。
  • 静态代码块。

Java代码块的核心问题是:

  • 代码块初始化是在什么时候?
  • 代码块执行顺序是怎样的?
  • 代码块在继承时,执行顺序是怎样的?

下面将对各种代码块就核心问题展开叙述!

局部代码块

在方法中出现,可以限定变量生命周期,及早释放,提高内存利用率。示例代码:

package com.chloneda.jutils.test;
/**
 * @author chloneda
 * @description: 局部代码块测试
 */
public class CodeBlockTest {
    public static void main(String[] args) {
        //局部代码块
        {
            int number = 100;
            System.out.println(number);
        }
        //找不到number变量,原因呢???
        //System. out.println(number);
    }
}

执行结果:

100

构造代码块

在类中方法外出现,每次调用构造方法都会执行,并且在构造方法前执行。示例代码:

package com.chloneda.jutils.test;

/**
 * @author chloneda
 * @description: 构造代码块类
 */
class CodeBlock {
    //构造代码块,在方法外出现
    {
        int number1 = 10;
        System.out.println("number1: " + number1);
    }

    //构造方法
    public CodeBlock() {
        System.out.println("这是构造方法");
    }

    //在构造代码块在构造方法前后出现,但构造代码块先于构造方法执行
    {
        int number2 = 100;
        System.out.println("number2: " + number2);
    }
}

//构造代码块测试类
public class CodeBlockTest {
    public static void main(String[] args) {
        // 创建对象
        CodeBlock codeBlock = new CodeBlock();
        // 注意:构造代码块通过构造方法自动调用
    }
}

执行结果:

number1: 10
number2: 100
这是构造方法

由上面的执行结果可知:

  • 构造代码块依赖于构造方法,而且优先于构造函数执行,即实例对象建立,才会运行构造代码块,类不能调用构造代码块的。

构造代码块与构造函数的区别:构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化,因为构造函数是可以多个的,运行哪个构造函数就会建立什么样的对象,但无论建立哪个对象,都会先执行相同的构造代码块。

也就是说,构造代码块中定义的是不同对象共性的初始化内容。

同步代码块

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

需要说明的是Synchronized同步代码块是一种高开销的操作,因此我们应该尽量减少被同步的内容,在很多场景,我们没有必要去同步整个方法,而只需要同步部分代码即可,也就是使用同步代码块(JDK源码中有很多应用)。

同步代码块示例如下。

package com.chloneda.jutils.test;

/**
 * @author chloneda
 * @description: 同步代码块测试
 */
public class CodeBlock 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();
    }
}

此外,静态代码是属于类而不是属于对象的,因此使用Synchronized来修饰静态方法和静态对象的时候,类下的所有对象都会被锁定。

静态代码块

在类中方法外出现,并加上static修饰,常用于给类进行初始化,在加载的时候就执行,并且静态代码块执行一次。

代码块执行顺序

首先我们验证一下代码块执行顺序,示例代码如下。

package com.chloneda.jutils.test;

/**
 * @author chloneda
 * @description: 验证代码块执行顺序
 */
class StatisCodeBlock {
    //静态代码块,在方法外出现
    static {
        int number1 = 20;
        System.out.println("1、静态代码块变量: " + number1);
    }

    //构造代码块,在方法外出现
    {
        int number2 = 100;
        System.out.println("2、构造代码块变量: " + number2);
    }

    public StatisCodeBlock() {
        System.out.println("这是构造方法 StatisCodeBlock()");
    }

    static {
        int number3 = 200;
        System.out.println("3、静态代码块变量: " + number3);
    }

    //在构造代码块在构造方法前后,但构造代码块先于构造方法执行
    {
        int number4 = 1000;
        System.out.println("4、构造代码块变量: " + number4);
    }
}

//静态代码块测试类
public class CodeBlockTest {
    public static void main(String[] args) {
        // 创建对象
        StatisCodeBlock codeBlock = new StatisCodeBlock();
        // 注意:构造代码块通过构造方法自动调用
        System.out.println("======我是分割线======");
        StatisCodeBlock codeBlock2 = new StatisCodeBlock();
    }
}

执行结果:

1、静态代码块变量: 20
3、静态代码块变量: 200
2、构造代码块变量: 100
4、构造代码块变量: 1000
这是构造方法 StatisCodeBlock()
======我是分割线======
2、构造代码块变量: 100
4、构造代码块变量: 1000
这是构造方法 StatisCodeBlock()

由上面的执行结果可知:

  • 静态代码块:在类加载JVM时初始化,且只被执行一次;常用来执行类属性的初始化;静态块优先于各种代码块以及构造函数;此外静态代码块不能访问普通变量。

  • 构造代码块:每次调用构造方法,构造代码块都执行一次;构造代码块优先于构造函数执行;同时构造代码块的运行依赖于构造函数。

继承中代码块执行顺序

下面再我们验证一下继承中代码块执行顺序,示例代码如下。

package com.chloneda.jutils.test;

/**
 * @author chloneda
 * @description: 验证继承中代码块执行顺序
 */
class Parent {
    //静态代码块,在方法外出现
    static {
        int number1 = 20;
        System.out.println("1、父类静态代码块变量: " + number1);
    }

    //构造代码块,在方法外出现
    {
        int number2 = 100;
        System.out.println("2、父类构造代码块变量: " + number2);
    }

    public Parent() {
        System.out.println("父类构造方法 Parent()");
    }

    static {
        int number3 = 200;
        System.out.println("3、父类静态代码块变量: " + number3);
    }

    //在构造代码块在构造方法前后,但构造代码块先于构造方法执行
    {
        int number4 = 1000;
        System.out.println("4、父类构造代码块变量: " + number4);
    }
}

class Child extends Parent {
    //静态代码块,在方法外出现
    static {
        int number1 = 2001;
        System.out.println("11、子类静态代码块变量: " + number1);
    }

    //构造代码块,在方法外出现
    {
        int number2 = 10001;
        System.out.println("22、子类构造代码块变量: " + number2);
    }

    public Child() {
        System.out.println("子类构造方法 Child()");
    }

    static {
        int number3 = 2002;
        System.out.println("33、子类静态代码块变量: " + number3);
    }

    //在构造代码块在构造方法前后,但构造代码块先于构造方法执行
    {
        int number4 = 100002;
        System.out.println("44、子类构造代码块变量: " + number4);
    }
}

public class CodeBlockTest {
    public static void main(String[] args) {
        // 创建对象
        Child child = new Child();
        // 注意:构造代码块通过构造方法自动调用
    }
}

执行结果如下。

1、父类静态代码块变量: 20
3、父类静态代码块变量: 200
11、子类静态代码块变量: 2001
33、子类静态代码块变量: 2002

2、父类构造代码块变量: 100
4、父类构造代码块变量: 1000
父类构造方法 Parent()

22、子类构造代码块变量: 10001
44、子类构造代码块变量: 100002
子类构造方法 Child()

由此可见继承中代码块执行顺序:父类静态块 ==> 子类静态块 ==> 父类代码块 ==> 父类构造器 ==> 子类代码块 ==> 子类构造器 。

小结

通过上面的例子讲解,现在可以解答代码块的核心问题了!

  • 静态代码块:在类加载JVM时初始化,且只被执行一次;常用来执行类属性的初始化;静态块优先于各种代码块以及构造函数;此外静态代码块不能访问普通变量。

  • 构造代码块:每次调用构造方法,构造代码块都执行一次;构造代码块优先于构造函数执行;同时构造代码块的运行依赖于构造函数。

代码块初始化时机:构造代码块在实例对象创建时进行初始化;静态代码块在类加载时进行初始化。

代码块执行顺序:静态代码块 ==> main()方法 ==> 构造代码块 ==> 构造方法 ==> 局部代码块 。

继承中代码块执行顺序:父类静态块 ==> 子类静态块 ==> 父类代码块 ==> 父类构造器 ==> 子类代码块 ==> 子类构造器 。

这就是java代码块的全部内容,大家理解了吗?

你可能感兴趣的:(Java 代码块详解)