Java初始化执行顺序
前言
关于Java类的成员初始化顺序，一直是笔试中常见的基础考题，今天就执行顺序写一篇博文
主要从：构造函数，构造代码块，静态代码块，继承关系分析
构造函数
public A(){
//构造函数 to do something
}- 对象新建时，调用对应的构造函数
- 构造函数的作用是用于给对象进行初始化
- 一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次
构造代码块
{
//构造代码块 to do something
}public class InitTest {
static int i = 2;
{
i *= 2;
}
public InitTest(){
System.out.println("构造函数:" + i);
}
public static void main(String[] args) {
System.out.println(i);
InitTest test = new InitTest();
System.out.println(i);
}
{
i *= 3;
}
}
运行结果：
2
构造函数:12
12
- 构造代码块是在对象创建的时候执行的，如果没有创建对象不会执行构造代码块，而且构造代码块执行顺序先于构造函数的执行顺序。
- 构造代码块的作用是给对象进行初始化
- 构造代码块与构造函数的区别是：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化，构造函数可以多次调用，而构造代码块第一次创建对象就会调用，而且仅一次
静态代码块
public class InitTest {
static int i = 2;
static{
i *= 2;
}
public static void main(String[] args) {
System.out.println(i);
}
static{
i *= 3;
}
}
结果：
12- 静态代码块随着类的加载而执行，只执行一次，并且优先于主函数。具体说，静态代码块是由类调用的。类调用时，先执行静态代码块，然后才执行主函数的。
静态代码块其实就是给类初始化的，而构造代码块是给对象初始化的。
单个类中例子
public class InitTest {
InitTest() {
System.out.println("构造函数");
}
{
System.out.println("构造代码块");
}
static {
System.out.println("静态代码块");
}
public static void main(String[] args) {
InitTest test1 = new InitTest();
InitTest test2 = new InitTest();
}
}
结果：
静态代码块
构造代码块
构造函数
构造代码块
构造函数结论：执行顺序从先到后为： 静态变量->静态代码块->变量->构造代码块-> 构造函数
继承中的初始化顺序
父类：
package com.hq.initTest;
/**
* 父类
* @author Huangqing
* @date 2018/6/27 15:54
*/
public class A {
static {
System.out.println("父类：静态代码块");
}
{
System.out.println("父类: 构造代码块");
}
public A(){
System.out.println("父类：构造函数");
}
private static String staticParentString = staticInitParent();
private String parentString = initParent();
public static String staticInitParent(){
System.out.println("父类：静态方法，被静态成员变量赋值调用");
return "staticInitParent";
}
public String initParent() {
System.out.println("父类：普通成员方法，被普通成员变量赋值调用");
return "initParent";
}
}
子类：
package com.hq.initTest;
/**
* 子类
* @author Huangqing
* @date 2018/6/27 15:54
*/
public class B extends A {
private static String staticChildString = staticInitChild();
private String childString = initChild();
static {
System.out.println("子类：静态代码块");
}
{
System.out.println("子类: 构造代码块");
}
public B(){
System.out.println("子类：构造函数");
}
public static String staticInitChild(){
System.out.println("子类：静态方法，被静态成员变量赋值调用");
return "staticInitParent";
}
public String initChild() {
System.out.println("子类：普通成员方法，被普通成员变量赋值调用");
return "initParent";
}
}
主方法：
package com.hq.initTest;
/**
* 测试Java类的成员和初始化块（代码块）初始化顺序
* @author Huangqing
* @date 2018/6/27 15:53
*/
public class InitTest {
public static void main(String[] args) {
System.out.println("主函数执行开始");
new B();
System.out.println("主函数执行结束");
}
}
运行结果：
主函数执行开始
父类：静态代码块
父类：静态方法，被静态成员变量赋值调用
子类：静态方法，被静态成员变量赋值调用
子类：静态代码块
父类: 构造代码块
父类：普通成员方法，被普通成员变量赋值调用
父类：构造函数
子类：普通成员方法，被普通成员变量赋值调用
子类: 构造代码块
子类：构造函数
主函数执行结束
经测试，得到在继承关系中，父类和子类成员初始化执行顺序结论：
1.父类【静态成员】和【静态代码块】，按在代码中出现的顺序依次执行。
2.子类【静态成员】和【静态代码块】，按在代码中出现的顺序依次执行。
3.父类的【普通成员变量被普通成员方法赋值】和【普通代码块】，按在代码中出现的顺序依次执行。
4.执行父类的构造方法。
5.子类的【普通成员变量被普通成员方法赋值】和【普通代码块】，按在代码中出现的顺序依次执行。
6.执行子类的构造方法。
附上一道阿里的Java初始化执行顺序题
public class TestConstructOrder {
public static int k = 0;
public static int k1;
public int k2;
public static TestConstructOrder t1 = new TestConstructOrder("t1");
public static TestConstructOrder t2 = new TestConstructOrder("t2");
public static int i = print("i");
public static int n = 99;
public int j = print("j");
{
print("构造块");
}
static {
print("静态块");
}
public TestConstructOrder(String str) {
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++i;
++n;
}
public static int print(String str) {
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
return ++i;
}
/**
*
*/
public static void main(String[] args) {
TestConstructOrder t = new TestConstructOrder("init");
}
}
结果是：
1:j i=0 n=0
2:构造块 i=1 n=1
3:t1 i=2 n=2
4:j i=3 n=3
5:构造块 i=4 n=4
6:t2 i=5 n=5
7:i i=6 n=6
8:静态块 i=7 n=99
9:j i=8 n=100
10:构造块 i=9 n=101
11:init i=10 n=102整个的执行步骤：（下面的分析不包括父类内容）
加载类信息：
1、静态变量默认初始化
2、对静态变量赋值，加载静态代码块中内容 （赋值顺序按书写顺序）
创建对象：
1、实例变量初始化
2、实例变量赋值（依然按顺序）
3、构造代码块中内容
4、构造函数中内容
分析：
1、 首先Class文件由类装载器装载后，在JVM中将形成一份描述Class结构的元信息对象。
2、加载类信息，对静态变量默认初始化，此时并未赋值（初始化顺序与代码顺序无关，具体可能要研究JVM虚拟机）
public static int k // 初始化, k = 0
public static int k1; // 初始化，k1 = 0
public static TestConstructOrder t1 = null // 初始化类 t1, t1 = null
public static TestConstructOrder t2 = null // 初始化类 t2, t2 = null
public static int i // 初始化 i = 0
public static int n = 99; // 初始化 n = 0
3、对静态变量赋值，加载静态代码块中内容。
k = 0 // k赋值0
t1 = new TestConstructOrder (“t1”) // 这里创建一个对象
注意 这里因为要创建对象，所以会执行创建对象的步骤：
实例变量初始化：
public int k2;// 初始化k2 , k2 = 0
public int j; // 初始化j, j = 0
实例变量赋值：
j = print(“j”) // 会执行静态方法
打印结果：1:j i = 0 n = 0
因为在创建对象，而我们前面说过，在创建对象时，构造代码块先于构造函数执行，所以会执行构造代码块
打印结果：2:构造块 i = 1 n = 1
然后执行构造函数
打印结果：3:t1 i = 2 n = 2
同样的，给t2赋值也会跟t1一样
打印结果：
4:j i = 3 n = 3
5:构造快 i = 4 n = 4
6:t2 i = 5 n = 5
继续赋值：i = print(“i”)
打印结果：
7:i i = 6 n = 6
对n赋值：int n = 99 // 此时 n = 99
然后执行静态代码块
打印结果：
8:静态块 i = 7 n = 99
最后：执行主函数，新建对象，这里的初始化顺序不再多说了，跟t1的相同
打印结果：
9:j i = 8 n = 100
10:构造快 i = 9 n = 101
6:init i = 10 n = 102
相信这道题，已经足够让你了解Java类成员的初始化顺序，博主也是一开始被弄糊涂了，如果还有不明白的地方，欢迎留言。如果觉得写得不错，别忘了给点个赞~