【java】普通代码块、构造块、静态代码块的区别以及在继承关系中的使用

代码块定义：使用"{}"定义的一段代码
根据代码块定义的位置以及关键字，又可分为以下四种：

1. 普通代码块
2. 构造快
3. 静态块
4. 同步代码块（多线程中，本文不作介绍）

一、普通代码块

定义在方法中的代码块

public class javaTest {
    public static void main(String[] args) {
        {
            int x = 1;
            x = x*10;
            System.out.println(x);//10
        }//x的作用域只存在于{}中
        int x = 1;
        System.out.println(x*20);//20
    }
}

普通代码块只有在调用方法时才会执行。
一般如果方法中代码过长，为避免变量重名，使用普通代码块，不经常使用。

二、构造块

定义在类中的代码块，使用{}括起来，无任何修饰符

class Person{
    {
        System.out.println("person的构造块");
    }
    public Person(){
        System.out.println("person的构造方法");
    }
}
public class javaTest {
    public static void main(String[] args) {
        new Person();
        new Person();
    }
}
运行结果：
person的构造块
person的构造方法
person的构造块
person的构造方法

结论：
构造块优先于构造方法执行，每次产生一个新的对象，就调用一次构造块，因此，使用构造块可以对类中属性进行初始化操作。

三、静态代码块

静态代码块：使用static定义的代码块

static 
{
    ...
}

根据静态块所在的类的不同分为以下两种类型

1. 在非主类中
2. 在主类中

(一)、在非主类中

class Person{
    {
        System.out.println("person的构造块");
    }
    static
    {
        System.out.println("person的静态块");
    }
    public Person(){
        System.out.println("person的构造方法");
    }
}
public class javaTest {
    public static void main(String[] args) {
        new Person();
        new Person();
        new Person();
    }
}
运行结果：
person的静态块
person的构造块
person的构造方法
person的构造块
person的构造方法
person的构造块
person的构造方法

结论：
在非主类中，静态块优先于构造块执行。
无论产生多少实例化对象，静态块都只执行一次。
静态块的主要作用是为static属性进行初始化。
(二)、在主类中

public class javaTest {
    {
        System.out.println("主类的构造块");
    }
    static
    {
        System.out.println("主类的静态块");
    }
    public javaTest(){
        System.out.println("主类的构造方法");
    }
    public static void main(String[] args) {
        System.out.println("main方法");
    }
}
运行结果：
主类的静态块
main方法

静态块优先于main方法执行，由于没有对主类进行实例化操作，也就是没有进行new，所以主类中的构造方法和构造块不执行，main方法是程序的入口处

下面是一道笔试题：

class HelloA {
    //构造方法
    public HelloA(){
        System.out.println("Hello A!父类构造方法");//4
    }
    //非静态代码块（构造块）
    {
        System.out.println("i'm A class.父类非静态代码块");//3
    }
    //静态代码块
    static{
        System.out.println("static A 父类静态代码块");//1
    }
}
class HelloB extends HelloA {
    //构造方法
    public HelloB(){
        System.out.println("Hello B! 构造方法");//6
    }
    //非静态代码块（构造块）
    {
        System.out.println("i'm B class.非静态代码块");//5
    }
    //静态代码块
    static{
        System.out.println("static B 静态代码块");//2
    }
}
public class javaTest {
    public static void main(String[] args) {
        System.out.println("main方法");
        System.out.println("---start---");
        new HelloB();
        System.out.println("-----------");
        new HelloB();
        System.out.println("---end---");
    }
}
运行结果：
main方法
---start---
static A 父类静态代码块
static B 静态代码块
i'm A class.父类非静态代码块
Hello A!父类构造方法
i'm B class.非静态代码块
Hello B! 构造方法
-----------
i'm A class.父类非静态代码块
Hello A!父类构造方法
i'm B class.非静态代码块
Hello B! 构造方法
---end---

总结：
父类普通静态块>子类普通静态块>父类构造块>父类构造方法>子类构造块>子类构造方法 (静态代码块只执行一次)