Java中的代码块

缺乏、安全感 2024-03-31 16:15 63阅读 0赞

## 一、概念 ##

代码块又叫初始化块，是类的一部分，类似于方法，将逻辑语句封装在方法体中，通过\{\}包围起来。

但代码块又和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是在加载类时，或者创建对象时隐式调用。

## 二、语法 ##

> \[修饰符\]\{
> 
> 代码
> 
> \};

注意：

1.  修饰符是可以不写，但是要写的话，也只能写static。
2.  代码块分为两类，有static的叫做静态代码块，没有static修饰的，叫做普通代码块/非静态代码块也行，随便喊无所谓。
3.  \{\}后面的分号";"可以写，也可以不写，一般是写上。

## 三、代码块的使用场景 ##

当重载的构造器中有需要重复的代码时，可以使用代码块减少代码冗余。即如果多个构造器中都有重复的语句，可以将其抽取到代码块（也叫初始化块）中，提高代码的重用性。

public class codeBlock {
        public static void main(String[] args) {
            Movie movie1 = new Movie("你好，李焕英");
            Movie movie3 = new Movie("唐探3",100,"大导演");
    
        }
    }
    
    class Movie{
        private String name;
        private double price;
        private String director;
    
        //三个构造器构成重载
        //（1）下面的三个构造器都具有相同的语句
        //（2）代码看起来冗余
        //（3）这时把相同的代码放到一个代码块中即可
        //（4）此时，不管用哪个构造器创建对象，都会先调用代码块的内容
        //（5）代码块调用的优先顺序高于构造器
        {
            System.out.println("电影屏幕打开......");
            System.out.println("开始播放广告");
            System.out.println("电影即将开始......");
        }
    
        public Movie(String name) {
            System.out.println("Movie(String name)被调用");
            this.name = name;
        }
    
        public Movie(String name, double price) {
            this.name = name;
            this.price = price;
        }
    
        public Movie(String name, double price, String director) {
            System.out.println("Movie(String name, double price, String director)被调用");
            this.name = name;
            this.price = price;
            this.director = director;
        }
    }

> 输出结果是：
> 
>  *  电影屏幕打开......
>  *  开始播放广告......
>  *  电影即将开始......
>  *  Movie(String name)被调用
>  *  电影屏幕打开......
>  *  开始播放广告......
>  *  电影即将开始......
>  *  Movie(String name, double price, String director)被调用
> 
> 可以看出代码块的优先级要高于构造器，先执行代码块再执行构造器。

## 四、代码块的细节 ##

1、static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着**类的加载**而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行一次。

public class CodeBlockDetail{
        psvm{
            AA aa1 = new AA();
            AA aa2 = new AA();
        }
    }
    class AA{
        //静态代码块，在类加载的时候执行，并且只会执行一次
        static{
            sout("AA的静态代码块1被执行......")
        }
    }

输出结果如下：

> AA的静态代码块1被执行......

2、普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。如果只是使用类的静态成员时，普通代码块并不会被执行。

public class CodeBlockDetail{
        psvm{
            AA aa1 = new AA();
            AA aa2 = new AA();
        }
    }
    class AA{
        //静态代码块，在类加载的时候执行，并且只会执行一次。普通代码块每实例化一个对象，就执行一次
        static{
            sout("AA的静态代码块1被执行......")
        }
        {
            sout("AA的普通代码块......")
    
        }
    }

输出结果如下：

> AA的静态代码块1被执行......
> 
> AA的普通代码块......
> 
> AA的普通代码块......

3、说白了就是，静态代码块跟类加载有关，类加载的同时执行静态代码块，且只执行一次。普通代码块跟创建对象实例有关（和类加载无关），且每创建一个对象实例，就加载一次。（普通代码块可以看作是构造器的补充，构造器被调用了，普通代码快就会被调用）。

4、静态代码块里面只能调用静态成员（静态方法和静态属性），普通代码块可以调用任意成员。

## 五、类什么时候被加载（重要） ##

1、创建对象实例时(new)，类会被加载：

public class CodeBlockDetail{
        psvm{
            //创建对象实例时会加载类
            AA aa = new AA();
        }
    }
    class AA{
        //静态代码块
        static{
            sout("AA的静态代码块1被执行......")
        }
    }

输出结果如下：

> AA的静态代码块1被执行......

2、创建子类对象实例时，父类也会被加载，而且父类先被加载，子类后被加载（先有爷爷后有爹，有了爹才有儿子）：

public class CodeBlockDetail{
        psvm{
            //创建子类对象实例时，父类也会被加载
            AA aa = new AA();
        }
    }
    
    class BB{
        //静态代码块
        static{
            sout("BB的静态代码块被执行......")
        }
    
    class AA extends BB{
        //静态代码块
        static{
            sout("AA的静态代码块被执行......")
        }
    }

输出结果如下：（**因为继承的本质是先加载父类，再加载子类**）

> BB的静态代码块被执行......
> 
> AA的静态代码块被执行......

3、使用类的静态成员时（静态属性、静态方法）：

public class CodeBlockDetail{
        psvm{
            //使用类的静态属性
            sout(Cat.n1);
        }
    }
    
    class Cat{
        //静态属性
        public static int n1 = 999;
        //静态代码块
        static{
            sout("Cat的静态代码块被执行......")
        }
    }

输出结果如下：

> Cat的静态代码块被执行......
> 
> 999

## 六、创建一个对象时，在一个类中的调用顺序 ##

1、调用静态代码块和静态属性初始化（静态代码块和静态属性初始化的优先级一样，如果有多个静态代码块和静态属性初始化，则按他们定义的顺序调用）。下图的代码，new一个对象时，输出的结果是A静态代码块01，getN1被调用...

![fd4b481294e44648845b87b310cf958b.png][]

2、调用普通代码块和普通属性初始化（普通代码块和普通属性初始化的优先级一样，如果有多个普通代码块和普通属性初始化，则按他们定义的顺序调用）。

3、调用构造方法。

**Tips**: 静态代码块和静态属性在类加载时，就执行完毕了，因此优先于构造器和普通代码块。

## 七、存在继承关系时，创建一个对象时的调用顺序（引出） ##

构造器的最前面其实隐含了super()和调用普通代码块，AAA的父类是object。

class{
        BBB bbb = new BBB();
    }
    
    class AAA{
        {
            sout("AAA的普通代码块");
        }
    
        public AAA(){
            //(1)super()
            //(2)调用本类的普通代码块
            sout("AAA()构造器被调用");
        }
    }
    
    class BBB extends AAA{
        {
            sout("BBB的普通代码块");
        }
    
        public BBB(){
            //(1)super()
            //(2)调用本类的普通代码块
            sout("BBB()构造器被调用");
        }
    }

输出结果如下：

> AAA的普通代码块
> 
> AAA()构造器被调用
> 
> BBB的普通代码块
> 
> BBB()构造器被调用

## 八、创建一个子类对象时，他们的静态代码块、静态属性初始化、普通代码块、普通属性初始化、构造方法的调用顺序 ##

> 1.  父类的静态代码块和静态属性初始化（优先级一样，按定义顺序执行）
> 2.  子类的静态代码块和静态属性初始化（优先级一样，按定义顺序执行）
> 3.  父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
> 4.  父类的构造方法
> 5.  子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
> 6.  子类的构造方法

[fd4b481294e44648845b87b310cf958b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/193406a2da364ed592f27ec01d64d1e9.png