Java基础6——深入理解五种类型的代码块与代码加载顺序

代码块与代码加载顺序

代码块

public class Test {
    {
        
    }
}

  这种形式的程序段我们将其称之为代码块，所谓代码块就是用大括号({ })将多行代码封装在一起，形成一个独立的数据体，用于实现特定的算法。一般来说代码块是不能单独运行的，它必须要有运行主体。在Java中代码块主要分为一下几种：

1.普通代码块

  普通代码块是我们用得最多的也是最普遍的，它就是在方法名后面用{ }括起来的代码段。普通代码块是不能够单独存在的，它必须要紧跟在方法名后面。同时也必须要使用方法名调用它。

public class Test {
    public void test(){
        System.out.println("普通代码块");
    }
}

2.静态代码块

  想到静态我们就会想到static，静态代码块就是用static修饰的用{ }括起来的代码段，它的主要目的就是对静态属性进行初始化。

public class Test {
    static{
        System.out.println("静态代码块");
    }
}

3.同步代码块

  使用 synchronized 关键字修饰，并使用“{ }”括起来的代码片段，它表示同一时间只能有一个线程进入到该方法块中，是一种多线程保护机制。

4.构造代码块

  在类中直接定义没有任何修饰符、前缀、后缀的代码块即为构造代码块。我们明白一个类必须至少有一个构造函数，构造函数在生成对象时被调用。构造代码块和构造函数一样同样是在生成一个对象时被调用，那么构造代码在什么时候被调用？如何调用的呢？看如下代码：

public class Test {
    /**
     * 构造代码
     */
    {
        System.out.println("执行构造代码块...");
    }
    
    /**
     * 无参构造函数
     */
    public Test(){
        System.out.println("执行无参构造函数...");
    }
    
    /**
     * 有参构造函数
     * @param id  id
     */
    public Test(String id){
        System.out.println("执行有参构造函数...");
    }
}

  new一个对象的时候总是先执行构造代码，再执行构造函数，但是有一点需要注意构造代码不是在构造函数之前运行的，它是依托构造函数执行的。正是由于构造代码块有这几个特性。
  如果一个类中存在若干个构造函数，这些构造函数都需要对实例变量进行初始化，如果我们直接在构造函数中实例化，必定会产生很多重复代码，繁琐和可读性差。这里我们可以充分利用构造代码块来实现。这是利用编译器会将构造代码块添加到每个构造函数中的特性。

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

5.局部代码块(补充)

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

 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 < 1000) {
                list.add(i ++);
            }
            for (Integer j : list) {
                System.out.println(j);
            }
            System.out.println("gogogo");
        }
        System.out.println("hello");
    }
}
--------------------- 
作者：How 2 Play Life 
来源：CSDN 
原文：https://blog.csdn.net/a724888/article/details/80069472 
版权声明：本文为博主原创文章，转载请附上博文链接！

代码块加载顺序

1. 静态代码块，它是随着类的加载而被执行，只要类被加载了就会执行，而且只会加载一次，主要用于给类进行初始化。
2. 构造代码块，每创建一个对象时就会执行一次，且优先于构造函数，主要用于初始化不同对象共性的初始化内容和初始化实例环境。
3. 构造函数，每创建一个对象时就会执行一次。同时构造函数是给特定对象进行初始化，而构造代码是给所有对象进行初始化，作用区域不同。
   通过上面的分析，他们三者的执行顺序应该为：静态代码块 > 构造代码块 > 构造函数。

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("静态代码块调用");
    }
}
--------------------- 
作者：How 2 Play Life 
来源：CSDN 
原文：https://blog.csdn.net/a724888/article/details/80069472 
版权声明：本文为博主原创文章，转载请附上博文链接！