java 常考面试基础代码块与代码加载顺序 static

港控/mmm° 2022-03-17 03:30 228阅读 0赞

在面试大型公司时，如果遇到大型国企或者大的互联网私企，笔试中经常遇到代码块和代码加载顺序的笔试题。这里做一个总结，也方便各位小伙伴不晕车。

源码github地址：https://github.com/harrypitter/JavaBase.git

部分转载自：[https://blog.csdn.net/a724888/article/details/80069472][https_blog.csdn.net_a724888_article_details_80069472]

**目录**

简介

局部代码块

构造代码块

静态代码块

笔试题

--------------------

# 简介 #

本文主要介绍了三种代码块的特性和使用方法。

*代码块：用\{\}包围的代码*

java中的代码块按其位置划分为四种：

## 局部代码块 ##

位置：局部位置（方法内部）  
作用：限定变量的生命周期，尽早释放，节约内存  
调用：调用其所在的方法时执行

public class 局部代码块 {
    @Test
    public void test (){
        B b = new B();
        b.go();
    }
    }
    class B {
        B(){}
        public void go() {
            //方法中的局部代码块，一般进行一次性地调用，调用完立刻释放空间，避免在接下来的调用过程中占用栈空间
            //因为栈空间内存是有限的，方法调用可能会会生成很多局部变量导致栈内存不足。
            //使用局部代码块可以避免这样的情况发生。
            {
                int i = 1;
                ArrayList<Integer> list = new ArrayList<>();
                while (i < 10) {
                    list.add(i ++);
                }
                for (Integer j : list) {
                    System.out.println(j);
                }
                System.out.println("gogogo");
            }
            System.out.println("hello");
        }
    }

输出结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70][]

##    构造代码块 ##

位置：类成员的位置，就是类中方法之外的位置  
作用：把多个构造方法共同的部分提取出来，共用构造代码块  
调用：每次调用构造方法时，都会优先于构造方法执行，也就是每次new一个对象时自动调用，对对象的初始化

**对象一实例化就执行，每实例化一次执行一次；**

class A{
        int i = 1;
        int initValue;//成员变量的初始化交给代码块来完成
        {
            //代码块的作用体现于此：在调用构造方法之前，用某段代码对成员变量进行初始化。
            //而不是在构造方法调用时再进行。一般用于将构造方法的相同部分提取出来。
            //
            for (int i = 0;i < 100;i ++) {
                initValue += i;
            }
        }
        {
            System.out.println(initValue);
            System.out.println(i);//此时会打印1
            int i = 2;//代码块里的变量和成员变量不冲突，但会优先使用代码块的变量
            System.out.println(i);//此时打印2
            //System.out.println(j);//提示非法向后引用，因为此时j的的初始化还没开始。
            //
        }
        {
            System.out.println("代码块运行");
        }
        int j = 2;
        {
            System.out.println(j);
            System.out.println(i);//代码块中的变量运行后自动释放，不会影响代码块之外的代码
        }
        A(){
            System.out.println("构造方法运行");
        }
    }
    public class 构造代码块 {
        @Test
        public void test() {
            A a = new A();
        }
    }

执行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70 1][]

##    静态代码块 ##

位置：类成员位置，用static修饰的代码块

作用：对类进行一些初始化  只加载一次，当new多个对象时，只有第一次会调用静态代码块，因为，静态代码块是属于类的，所有对象共享一份

调用: new 一个对象时自动调用

public class 静态代码块 {
    
    @Test
    public void test() {
        C c1 = new C();
        C c2 = new C();
        //结果,静态代码块只会调用一次，类的所有对象共享该代码块
        //一般用于类的全局信息初始化
        //静态代码块调用
        //代码块调用
        //构造方法调用
        //代码块调用
        //构造方法调用
    }
    
    }
    class C{
        C(){
            System.out.println("构造方法调用");
        }
        {
            System.out.println("代码块调用");
        }
        static {
            System.out.println("静态代码块调用");
        }
    }

调用结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70 2][]

执行顺序 静态代码块 —–> 构造代码块 ——-> 构造方法

# 笔试题 #

实际面试题：

写出下列程序输出结果：

public class HelloA {
        public HelloA(){
            System.out.println("HelloA");
        }
        {
            System.out.println("I'm A class");
        }
    
        static {
            System.out.println("static A");
        }
    }
    
    public class HelloB extends HelloA {
        public HelloB(){
            System.out.println("HelloB");
        }
        {
            System.out.println("I'm B class");
        }
    
        static {
            System.out.println("static B");
        }
    
        public static void main(String[] args) {
            new HelloB();
        }
    }

执行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70 3][]

分析：首先要知道静态代码块是随着类的加载而加载,而构造代码块和构造方法都是随着对象的创建而加载

1,在编译HelloB.java时,由于HelloB 继承 HelloA,先加载了HelloA类,因此HelloA类的静态代码块首先执行,而后加载HelloB类,HelloB类的静态代码块执行,这没什么好说的

2,然后创建HelloB的对象,大家都知道构造代码块优先于构造方法执行,这时候问题来了,这时应该先看HelloB类的构造方法,HelloB类里的构造方法里有一句隐式的super()首先被执行,所以找到HelloA类的构造方法,而HelloA类的构造方法中也有一句隐式的super()执行(调用Object类的构造方法),并没有什么返回结果,接下来才是在执行HelloA类构造方法的方法体前先执行了HelloA类的构造代码块(I'm A class),再执行HelloA类构造方法的方法体(也就是Hello A),最后又回到HelloB类的构造方法中,这时HelloB类的super()已经执行完了,在执行HelloB类构造方法的方法体前先执行HelloB类的构造代码块(I'm B class),再执行Zi类构造方法的方法体(HellB).

无继承初始化顺序：

![20190222143419466.png][]

![20190222143438483.png][]

有继承初始化顺序：

![20190222143507320.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70 4][]

接下来看一道阿里笔试题：

public class B
    {
        public static B t1 = new B();
        public static B t2 = new B();
        {
            System.out.println("构造块");
    
        }
        static
        {
            System.out.println("静态块");
    
        }
    
        public static void main(String[] args)
        {
    
            B t =new B();
    
        }
    }

执行结果是：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70 5][]

为什么不是：

*静态块*

*构造块*

*原因是：*

静态块：用静态申明，JVM加载类时执行，仅执行一次

构造块：类中直接用\{\}定义，每一次创建对象时执行

执行顺序优先级：静态块>主（）>构造块>构造方法

因为静态声明缘故T1，T2也上升到静态位，与静态块处于同一优先级，同一优先级就先取按顺序来构造对象，构造对象，静态块

[https_blog.csdn.net_a724888_article_details_80069472]: https://blog.csdn.net/a724888/article/details/80069472
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70]: /images/20220317/cb3513ad5d584071845a8881e88ef68c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70 1]: /images/20220317/a20500002fdc4d36a90926585a2e7b84.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70 2]: /images/20220317/124ae43710bc4eef8fb45169c107f84c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70 3]: /images/20220317/8b1cd30ce1f54d7faf9060b5d6f08a29.png
[20190222143419466.png]: /images/20220317/2584cb4801ae4df0a58f21a30711bf27.png
[20190222143438483.png]: /images/20220317/d92dca0630c146899dca4fd14480144e.png
[20190222143507320.png]: /images/20220317/796a880952e64ab9934252bea2bc6742.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70 4]: /images/20220317/37b59ba71cdd4346b8f0b2f1697e7677.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70 5]: /images/20220317/5580bb933191445da33ebbea89330b9f.png