Java中static靜態(tài)變量的初始化完全解析
更新時間：2016年06月15日 08:55:26 作者：threezj
static所聲明的變量在Java中有一個初始化的先后順序,帶著這個問題接下來我們就來進(jìn)行Java中static靜態(tài)變量的初始化完全解析:
靜態(tài)變量初始化順序
1.簡單規(guī)則
首先先看一段最普遍的JAVA代碼：
public class Test
{
public static Test1 t = new Test1();
public static int a = 0;
public static int b;
public static void main(String[] arg)
{
System.out.println(Test.a);
System.out.println(Test.b);
}
}
class Test1
{
public Test1()
{
Test.a++;
Test.b++;
}
}
這里先猜下控制臺輸出結(jié)果是什么?
OK, 或許你已經(jīng)猜到下面了結(jié)果了,那么你還是熟悉Java的。
復(fù)制代碼 代碼如下:
0 1
如果你不明白是為什么會輸出上面的結(jié)果,那么我來告訴你。
Java靜態(tài)變量初始化遵循以下規(guī)則:
- 靜態(tài)變量會按照聲明的順序先依次聲明并設(shè)置為該類型的默認(rèn)值，但不賦值為初始化的值。
- 聲明完畢后,再按聲明的順序依次設(shè)置為初始化的值，如果沒有初始化的值就跳過。
看了這個就會明白,原來Test.a的值變化了三次。
聲明時設(shè)置為0>>Test1::Test1里設(shè)置為1>>Test.a初始化為0
2.復(fù)雜規(guī)則
明白了這個，請再看下面的代碼。
public class A
{
public static int b = B.a;
public static A plus =new A("A");
public static final int finalInt = (int)(Math.random()*100);
public static B p = new B("A");
public static final String finalStr = "finalStr";
public static final Integer finalInteger = new Integer(10);
public static int a = 1;
public static B c = null;
public A(String from)
{
System.out.println("----------- begin A::A ----------------");
System.out.println("A::A, from="+from);
System.out.println("A::A, A.b="+A.b);
System.out.println("A::A, A.finalInt="+A.finalInt);
System.out.println("A::A, B.a="+B.a);
System.out.println("A::A, B.plus="+B.plus);
System.out.println("----------- end A::A ----------------");
}
public static void main(String[] arg)
{
System.out.println("main, A.b="+A.b);
System.out.println("main, B.t="+B.t);
System.out.println("main, C.a="+C.a);
}
}
class B
{
public static int t = A.a;
public static A plus = new A("B");
public static int a = 1;
public B(String from)
{
System.out.println("----------- begin B::B ----------------");
System.out.println("B::B, from="+from);
System.out.println("B::B, B.a="+B.a);
System.out.println("B::B, A.a="+A.a);
System.out.println("B::B, A.p="+A.p);
System.out.println("B::B, A.plus="+A.plus);
System.out.println("B::B, A.finalInt="+A.finalInt);
System.out.println("B::B, A.finalInteger="+A.finalInteger);
System.out.println("B::B, A.finalStr="+A.finalStr);
System.out.println("----------- end B::B ----------------");
}
}
class C
{
public static final A a = new A("C");
}
這個你還能猜到輸出結(jié)果嗎? 我是在一邊測試一邊寫的,所以我沒猜出來.哈哈
控制臺輸出結(jié)果為：
----------- begin A::A ---------------- A::A, from=B A::A, A.b=0 A::A, A.finalInt=0 A::A, B.a=0 A::A, B.plus=null ----------- end A::A ---------------- ----------- begin A::A ---------------- A::A, from=A A::A, A.b=1 A::A, A.finalInt=0 A::A, B.a=1 A::A, B.plus=A@a90653 ----------- end A::A ---------------- ----------- begin B::B ---------------- B::B, from=A B::B, B.a=1 B::B, A.a=0 B::B, A.p=null B::B, A.plus=A@1fb8ee3 B::B, A.finalInt=61 B::B, A.finalInteger=null B::B, A.finalStr=finalStr ----------- end B::B ---------------- main, A.b=1 main, B.t=0 ----------- begin A::A ---------------- A::A, from=C A::A, A.b=1 A::A, A.finalInt=61 A::A, B.a=1 A::A, B.plus=A@a90653 ----------- end A::A ---------------- main, C.a=A@61de33
這個結(jié)果你沒猜到吧,哈哈.
要一句一句的講解程序執(zhí)行結(jié)果,還是要很到的篇幅的.這里就直接寫出Java靜態(tài)變量初始化遵循的規(guī)則了。
第一段的規(guī)則依然有效，只是不健全。
- 只有主動請求一個類,這個類才會初始化,僅包含靜態(tài)變量,函數(shù),等靜態(tài)的東西.
- 繼承關(guān)系時,先初始化父類,后初始化子類.
- 靜態(tài)變量會按照聲明的順序先依次聲明并設(shè)置為該類型的默認(rèn)值,但不賦值為初始化的值.
- 聲明完畢后,再按聲明的順序依次設(shè)置為初始化的值,如果沒有初始化的值就跳過.
- 當(dāng)初始化A.b=B.a時,暫停初始化A.b,設(shè)置當(dāng)前類為B,跳到步驟3,并執(zhí)行.
- 當(dāng)初始化B.plus = new A時,暫停初始化B.plus,實例化A并賦值給B.plus.
- 當(dāng)A的構(gòu)造函數(shù)里需要獲得B.a的值時,B.a還初始化并處于暫停初始化狀態(tài),直接取B.a的當(dāng)前值,不再等待B.a初始化.
- final,靜態(tài)常量其實是遵循普通靜態(tài)變量的初始化的,但是在編譯時,編譯器會將不可變的常量值在使用的地方替換掉.可以用Java反編譯工具查看.
static數(shù)據(jù)的初始化
加上static限定的字段，是所謂的類字段，也就是說這個字段的擁有者不是對象而是類。無論創(chuàng)建多少對象，static數(shù)據(jù)都只有一份。
類內(nèi)總是先初始化static字段，再初始化一般字段。接著初始化構(gòu)造器。但是如果不創(chuàng)建這個類的對象，那這個對象是不會進(jìn)行初始化的，并且只執(zhí)行一次。
如下面的代碼，在StaticInitialization類中，先初始化static Table table = new Table();，然后才去初始化Table對象，不然是不會被初始化的。
class Bowl {
Bowl(int marker) {
print("Bowl(" + marker + ")");
}
void f1(int marker) {
print("f1(" + marker + ")");
}
}
class Table {
static Bowl bowl1 = new Bowl(1);
Table() {
print("Table()");
bowl2.f1(1);
}
void f2(int marker) {
print("f2(" + marker + ")");
}
static Bowl bowl2 = new Bowl(2);
}
class Cupboard {
Bowl bowl3 = new Bowl(3);
static Bowl bowl4 = new Bowl(4);
Cupboard() {
print("Cupboard()");
bowl4.f1(2);
}
void f3(int marker) {
print("f3(" + marker + ")");
}
static Bowl bowl5 = new Bowl(5);
}
public class StaticInitialization {
public static void main(String[] args) {
print("Creating new Cupboard() in main");
new Cupboard();
print("Creating new Cupboard() in main");
new Cupboard();
table.f2(1);
cupboard.f3(1);
}
static Table table = new Table();
static Cupboard cupboard = new Cupboard();
}
輸出：
Bowl(1) Bowl(2) Table() f1(1) Bowl(4) Bowl(5) Bowl(3) Cupboard() f1(2) Creating new Cupboard() in main Bowl(3) Cupboard() f1(2) Creating new Cupboard() in main Bowl(3) Cupboard() f1(2) f2(1) f3(1)
顯示的靜態(tài)初始化（也就是靜態(tài)塊）
把多個初始化語句包在一個static花括號里，叫做靜態(tài)塊，其實就是把多個static合在一起寫了，本質(zhì)是一樣的。只有首次創(chuàng)建對象或者首次訪問類的字段時才會執(zhí)行，而且僅僅一次。
class Cup {
Cup(int marker) {
print("Cup(" + marker + ")");
}
void f(int marker) {
print("f(" + marker + ")");
}
}
class Cups {
static Cup cup1;
static Cup cup2;
static {
cup1 = new Cup(1);
cup2 = new Cup(2);
}
Cups() {
print("Cups()");
}
}
public class ExplicitStatic {
public static void main(String[] args) {
print("Inside main()");
Cups.cup1.f(99); // (1)
}
// static Cups cups1 = new Cups(); // (2)
// static Cups cups2 = new Cups(); // (2)
}
輸出：
Inside main() Cup(1) Cup(2) f(99)
非靜態(tài)實例初始化
這個沒什么好講的，就是普通初始化，按順序執(zhí)行，可以多次執(zhí)行。
class Mug {
Mug(int marker) {
print("Mug(" + marker + ")");
}
void f(int marker) {
print("f(" + marker + ")");
}
}
public class Mugs {
Mug mug1;
Mug mug2;
{
mug1 = new Mug(1);
mug2 = new Mug(2);
print("mug1 & mug2 initialized");
}
Mugs() {
print("Mugs()");
}
Mugs(int i) {
print("Mugs(int)");
}
public static void main(String[] args) {
print("Inside main()");
new Mugs();
print("new Mugs() completed");
new Mugs(1);
print("new Mugs(1) completed");
}
}
Inside main() Mug(1) Mug(2) mug1 & mug2 initialized Mugs() new Mugs() completed Mug(1) Mug(2) mug1 & mug2 initialized Mugs(int) new Mugs(1) completed
相關(guān)文章
Spring Cloud詳解實現(xiàn)聲明式微服務(wù)調(diào)用OpenFeign方法
這篇文章主要介紹了Spring Cloud實現(xiàn)聲明式微服務(wù)調(diào)用OpenFeign方法，OpenFeign 是 Spring Cloud 家族的一個成員， 它最核心的作用是為 HTTP 形式的 Rest API 提供了非常簡潔高效的 RPC 調(diào)用方式，希望對大家有所幫助。一起跟隨小編過來看看吧2022-07-07
這篇文章主要為大家通過示例介紹了Java?泛型的上界和下界通配符，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2023-04-04
這篇文章主要介紹了使用Feign傳遞請求頭信息(Finchley版本)，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-03-03
springboot整合Quartz實現(xiàn)動態(tài)配置定時任務(wù)的方法
本篇文章主要介紹了springboot整合Quartz實現(xiàn)動態(tài)配置定時任務(wù)的方法，非常具有實用價值，需要的朋友可以參考下2017-10-10
這篇文章主要介紹Java的包裝類的一些特性，包裝類的作用，哪些類屬于包裝類等，文中有詳細(xì)的代碼示例，對我們的學(xué)習(xí)或工作有一定的幫助,需要的朋友可以參考下2023-05-05
windows自帶的游戲《掃雷》是陪伴了無數(shù)人的經(jīng)典游戲，本文將利用Java語言實現(xiàn)這一經(jīng)典的游戲，文中的示例代碼講解詳細(xì)，感興趣的可以學(xué)習(xí)一下2022-05-05
Java基于堆結(jié)構(gòu)實現(xiàn)優(yōu)先隊列功能示例
這篇文章主要介紹了Java基于堆結(jié)構(gòu)實現(xiàn)優(yōu)先隊列功能,結(jié)合實例形式分析了java優(yōu)先隊列的簡單定義與使用方法,需要的朋友可以參考下2017-11-11
SpringBoot+easypoi實現(xiàn)數(shù)據(jù)的Excel導(dǎo)出
這篇文章主要為大家詳細(xì)介紹了SpringBoot+easypoi實現(xiàn)數(shù)據(jù)的Excel導(dǎo)出，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-05-05
這篇文章主要為大家詳細(xì)介紹了Java基于IO流實現(xiàn)登錄和注冊功能，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-04-04
這篇文章主要介紹了Java效率提升神器jOOR，jOOR是一個第三方庫，通過鏈?zhǔn)紻SL接口，簡化了反射過程，更多相關(guān)內(nèi)容組要的朋友可以參考一下2022-07-07