Java类的初始化、变量的初始化

本文简单演示Java类的初始化、变量的初始化顺序，扎实Java 基础，编写高效的code哦

---

知识点

• Java常量,final 修饰,值被设定后不能再被修改
• 静态变量里,static 修饰,顾名思义，无须创建对象，便可在内存中申请一个存储空间进行存储
• 成员变量,也称实例变量，它随着当前对象的建立而建立，随着对象的销毁而销毁，存在于对象所在的堆内存中
• 构造器，创建class对象时执行
• 静态初始化块,执行优先级高于非静态的初始化块，它会在对象装载到 jvm的时候执行一次，执行完成便销毁，只能初始化 static 修饰的变量
• 非静态初始化块，执行的时候如果有静态初始化块，先执行静态初始化块再执行非静态初始化块，在每个对象生成时都会被执行一次，它可以初始化类的实例变量。但它会在构造函数执行之前被执行。

---

类的初始化顺序

Java中类初始化顺序，依次是（静态变量、静态初始化块）>（变量、初始化块）>构造器。。

实例代码

父类 Human

package com.lazy.pojos;

import com.lazy.interfaces.IBehaviour;

/**
 * Created by system on 16/9/10.
 */
public class Human /*extends Object*/ implements IBehaviour { //default super class Object
    String TAG = "Human";
    public static String sTAG = "static Human";
    protected long identifier = System.currentTimeMillis();//身份标识
    protected int age;
    protected int height;
    protected String name;

    /* 静态初始化块 */
    static {
        System.out.println("Human" + " 静态初始化块");
    }

    /* 初始化块 (实例初始化器)*/ {
        System.out.println(TAG + " 初始化块");
        System.out.println(TAG + " " + identifier);
    }

    public Human() {
        System.out.println(TAG + " 构造器");
    }

    @Override
    public void eat() {

    }
}

子类Woman

package com.lazy.pojos;

/**
 * Created by system on 16/9/10.
 */
public class Woman extends Human  {

}

子类Man

package com.lazy.pojos;

/**
 * Created by system on 16/9/10.
 */
public class Man extends Human {
    /* 静态变量 */
    public static String staticVar = "staticVar";

    /* 成员变量 */
    public String field = "field";

    String TAG = "Man";

    /* 静态初始化块 */
    static {
        System.out.println("Man 静态初始化块");
        System.out.println("Man staticVar =" + staticVar);
    }

    /* 初始化块 (类实例初始化器)*/ {
        System.out.println(TAG + " 初始化块");
        System.out.println(TAG + " field = " + field);
    }

    /* 构造器 */
    public Man() {
//        super(); //隐式
        System.out.println(TAG + " 构造器");
    }
}

测试类：FinalVarTest

public class InitializeOrderTest {

    public static void main(String[] args) {
        new Man();
        new Woman();
    }
}

执行结果：如图

Java 类的初始化,可以分为单一对象的初始化，已经有继承关系的对象初始化，然而java 所有类的基类都是Object。有基类的先初始化基类，再初始化自身。Woman 类之所以能调用基类构造器，皆因为Java 编译器，class 文件中生成了一个默认构造器。如下图

IntelliJ IDEA 能直接查看class 文件，而且调试功能更为强大

变量初始化顺序

实例代码

package com.lazy.pojos;

public class FinalVar {
    String mg = "msg";

    static String msg = "static msg";

    final static String msg2 = "final static msg";

    public static final String MSG = "MSG";

    public static final String MSG2 = "MSG" + 2; //MSG2 = "MSG2"

    public static final String MSG3 = "MSG" + "3"; // MSG3 = "MSG3"

    public static final String MSG4 = msg + "4"; //MSG4; 只 declare no value

    public static final String MSG5 = msg2 + "5"; //MSG5 = "final static msg5";

    public static String MSG6 = msg2 + "6"; //MSG6; 只 declare no value

    public final String MSG7 = msg2 + "7"; ///MSG7 = "final static msg7";

    public final String MSG8 = mg + "8"; //MSG8; 只 declare no value

    public static final int NUM = 100 * 10; //NUM =1000;

    public int num = 100 * 10; //NUM; 只 declare no value

    final String MG = "MG";

    static {
        System.out.println("static");
    }
}

对于变量我们如何测试变量的初始化顺序呢
- 查看Class 反编译后的代码
- Debug 变量

class 文件

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.lazy.pojos;

public class FinalVar {
    String mg = "msg";
    static String msg = "static msg";
    static final String msg2 = "final static msg";
    public static final String MSG = "MSG";
    public static final String MSG2 = "MSG2";
    public static final String MSG3 = "MSG3";
    public static final String MSG4;
    public static final String MSG5 = "final static msg5";
    public static String MSG6;
    public final String MSG7 = "final static msg7";
    public final String MSG8;
    public static final int NUM = 1000;
    public int num;
    final String MG;

    public FinalVar() {
        this.MSG8 = this.mg + "8";
        this.num = 1000;
        this.MG = "MG";
    }

    static {
        MSG4 = msg + "4";
        MSG6 = "final static msg6";
        System.out.println("static");
    }
}

测试代码

public class FinalVarTest {

    public static void main(String[] args) {
        System.out.println(FinalVar.MSG);
//        System.out.println(FinalVar.MSG4);
//        new FinalVar();
    }
}

由此可得:
1.static final 变量在编译时，编译器已经为之初始化值，static 变量要比成员变量优先初始化，仅初始化一次。——若代码中引用到 一个 static 变量，便会初始化整个类的static 变量，static final 变量则不会。
看代码
①如 static final 变量 MSG2 , 编译器自动为它 拼接成：MSG2。②再看 MSG4 ,它由 static 变量 msg + “4” ,msg 值不是final ,常量值，编译器只好先declare MSG4 这个变量，在 static 代码块中进行赋值; ③而 MSG5 变量的默认值为 “final static msg5”，④即 static final 变量在赋值时，值必须编译前就明确了. 若采用 static 变量进行赋值，—— 只能static 代码块中进行赋值。

2.对于 成员变量 MSG8 ，以下的声明的成员变量 如 num 打开class 文件看到都只在class 构造器中被赋值,经我测试只有成员变量赋值时引用了其它变量时,都会在构造器中被赋值。

如果你还不明白变量初始化顺序，可以在变量上打变量断点

debug运行代码便会挂起

最后

对于 变量的初始化来说，情况比较多，还得多实践。如果想了解jvm 类加载的请阅读 [ JVM 类加载的那些事 ]

对于本文的字符串拼接其细节的请参考 [ 浅谈Java String内幕 ]， [ 什么是字符串常量池？ ] 两篇文章。