代码块的理解学习

左手的ㄟ右手 2023-09-28 15:37 6阅读 0赞

#### 文章目录 ####

*  基本介绍
 *  基本语法
 *  代码块的好处
 *  代码块使用细节
 *   *  什么时候被执行
     *  两种代码块的执行顺序
     *  两种代码块在类中的执行顺序
     *  代码中成员权限要求
 *  总结

## 基本介绍 ##

代码块属于类中的成员，类似于方法，将逻辑语句封装在方法体中，通过`{}`包围起来。

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

## 基本语法 ##

修饰符 {
        
    
    代码}；

**说明注意：**

1.修饰符可写可不写，要写的话，也只能写static

2.若使用static修饰叫做静态代码块，若没有static修饰的叫做普通代码块

3逻辑语句可以为任何逻辑语句（输入输出，方法调用，循环等）

4`；`号可以写上，也可以省略

## 代码块的好处 ##

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

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

**代码案例:**

class Movie {
        
        private String name;
        private double price;
        private String director;
     
        //3个构造器->重载
     
        {
        
            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;
        }
    }

\*\*解释：\*\*三个构造器中由相同的语句，为了避免代码过于冗余，我们使用代码块来完成构造器的初始化，这时我们可以把相同的语句，放入到一个代码块中，这样当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容，最后，切记代码块调用的顺序优先于构造器。

## 代码块使用细节 ##

### 什么时候被执行 ###

1.  **static代码块的作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果时普通代码块，每创建一个对象就执行一次。**
2.  类什么时候被加载\*\*【重点】\*\*
    
    1.  创建对象实例时（new一个对象时）
    2.  创建子类对象实例，父类也会被加载
        
        这里解释一下为什么父类也会被加载，当我们创建子类对象时，都会含有一个构造器，默认为无参构造器，在构造器中存在一个隐含的super指向父类，所以如果父类也由静态代码块，会优先加载
    3.  使用类的静态成员时（静态属性，静态方法）
        
        eg：A 类 extends B类 的静态块
3.  普通代码块，在创建对象实例时，会被调用，创建一次，调用一次。
    
    如果仅是使用类的成员时，普通代码块并不会执行

class BB {
        
        {
        
            System.out.println("BB 的普通代码块2被执行。。。");
        }
        //静态代码块
        static {
        
            System.out.println("BB 的静态代码1被执行...");//1
        }
    
    }
    
    class AA extends BB {
        
    
        //静态代码块
        static {
        
            System.out.println("AA 的静态代码1被执行...");//2
        }
    
        {
        
            System.out.println("AA 的普通代码块2被执行。。。");
        }
    }
    
    //类被加载的情况举例
    //        1. 创建对象实例时(new)
             AA aa = new AA();
            //2. 创建子类对象实例，父类也会被加载, 而且，父类先被加载，子类后被加载
             AA aa2 = new AA();

![img][]

### 两种代码块的执行顺序 ###

这里我们先记住**静态代码块的执行是先于普通代码块的**，在后面详细介绍执行的先后顺序

创建一个对象时，在一个类调用顺序时（无继承关系）：**（重点）**

1.  调用静态代码块和静态属性初始化（静态代码块和静态属性初始化调用的优先级一样，按他们定义属性调用
2.  调用普通代码块和普通属性的初始化（普通代码块和普通属性初始化调用的优先级一起，按他们定义顺序调用）
3.  调用构造方法

class C02 {
        
    
        private int n1 = 100;
        private static  int n2 = 200;
        private static int n3 = 300;
    
        public C02() {
        
            System.out.print("C02构造器被调用...");
        }
        private void m1() {
        
            System.out.println("m1方法被调用...");
        }
        private static void m2() {
        
            System.out.println("m2方法被调用...");
        }
        static {
        
            //静态代码块，只能调用静态成员
            //System.out.println(n1);错误
            System.out.println(n2);//ok
            
            //m1();//错误
            m2();
        }
        {
        
            //普通代码块，可以使用任意成员
            System.out.println(n1);
            System.out.println(n2);//ok
            m1();
            m2();
        }
    }
    new C02();

![img][img 1]

### 两种代码块在类中的执行顺序 ###

创建一个子类对象时，在一个类调用顺序时的调用顺序：

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

class A02 {
         //父类
        
        private static int n1 = getVal01();
        static {
        
            System.out.println("A02的一个静态代码块..");//(2)
        }
        {
        
            System.out.println("A02的第一个普通代码块..");//(5)
        }
        public int n3 = getVal02();//普通属性的初始化
        public static int getVal01() {
        
            System.out.println("getVal01");//(1)
            return 10;
        }
    
        public int getVal02() {
        
            System.out.println("getVal02");//(6)
            return 10;
        }
        public A02() {
        //构造器
            //隐藏
            //super()
            //普通代码和普通属性的初始化......
            System.out.println("A02的构造器");//(7)
        }
    }
    
    class B02 extends A02 {
         //
        private static int n3 = getVal03();
        static {
        
            System.out.println("B02的一个静态代码块..");//(4)
        }
        public int n5 = getVal04();
        {
        
            System.out.println("B02的第一个普通代码块..");//(9)
        }
        public static int getVal03() {
        
            System.out.println("getVal03");//(3)
            return 10;
        }
        public int getVal04() {
        
            System.out.println("getVal04");//(8)
            return 10;
        }
        //一定要慢慢的去品..
        public B02() {
        //构造器
            //隐藏了
            //super()
            //普通代码块和普通属性的初始化...
            System.out.println("B02的构造器");//(10)
        }
    }
    
    new B02();

这里解释一下为什么静态代码块最先执行，因为静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块的

### 代码中成员权限要求 ###

**代码块只能直接调用静态成员，普通代码块可以调用任意成员**

## 总结 ##

最近正在复习java的基础知识，学习道代码块这块时发现对其还不够熟悉，故做笔记保存以便于以后复习。

[img]: https://img-blog.csdnimg.cn/img_convert/d379a899f67bb52cd3a26f45cd3bc0af.png
[img 1]: https://img-blog.csdnimg.cn/img_convert/556b9cd8654c460b469f837a66f89e9c.png