Java中static静态变量的初始化完全解析
静态变量初始化顺序
1.简单规则
首先先看一段最普遍的JAVA代码:
publicclassTest { publicstaticTest1t=newTest1(); publicstaticinta=0; publicstaticintb; publicstaticvoidmain(String[]arg) { System.out.println(Test.a); System.out.println(Test.b); } } classTest1 { publicTest1() { Test.a++; Test.b++; } }
这里先猜下控制台输出结果是什么?
OK,或许你已经猜到下面了结果了,那么你还是熟悉Java的。
01
如果你不明白是为什么会输出上面的结果,那么我来告诉你。
Java静态变量初始化遵循以下规则:
- 静态变量会按照声明的顺序先依次声明并设置为该类型的默认值,但不赋值为初始化的值。
- 声明完毕后,再按声明的顺序依次设置为初始化的值,如果没有初始化的值就跳过。
看了这个就会明白,原来Test.a的值变化了三次。
声明时设置为0>>Test1::Test1里设置为1>>Test.a初始化为0
2.复杂规则
明白了这个,请再看下面的代码。
publicclassA { publicstaticintb=B.a; publicstaticAplus=newA("A"); publicstaticfinalintfinalInt=(int)(Math.random()*100); publicstaticBp=newB("A"); publicstaticfinalStringfinalStr="finalStr"; publicstaticfinalIntegerfinalInteger=newInteger(10); publicstaticinta=1; publicstaticBc=null; publicA(Stringfrom) { System.out.println("-----------beginA::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("-----------endA::A----------------"); } publicstaticvoidmain(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); } } classB { publicstaticintt=A.a; publicstaticAplus=newA("B"); publicstaticinta=1; publicB(Stringfrom) { System.out.println("-----------beginB::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("-----------endB::B----------------"); } } classC { publicstaticfinalAa=newA("C"); }
这个你还能猜到输出结果吗?我是在一边测试一边写的,所以我没猜出来.哈哈
控制台输出结果为:
-----------beginA::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 -----------endA::A---------------- -----------beginA::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 -----------endA::A---------------- -----------beginB::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 -----------endB::B---------------- main,A.b=1 main,B.t=0 -----------beginA::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 -----------endA::A---------------- main,C.a=A@61de33
这个结果你没猜到吧,哈哈.
要一句一句的讲解程序执行结果,还是要很到的篇幅的.这里就直接写出Java静态变量初始化遵循的规则了。
第一段的规则依然有效,只是不健全。
- 只有主动请求一个类,这个类才会初始化,仅包含静态变量,函数,等静态的东西.
- 继承关系时,先初始化父类,后初始化子类.
- 静态变量会按照声明的顺序先依次声明并设置为该类型的默认值,但不赋值为初始化的值.
- 声明完毕后,再按声明的顺序依次设置为初始化的值,如果没有初始化的值就跳过.
- 当初始化A.b=B.a时,暂停初始化A.b,设置当前类为B,跳到步骤3,并执行.
- 当初始化B.plus=newA时,暂停初始化B.plus,实例化A并赋值给B.plus.
- 当A的构造函数里需要获得B.a的值时,B.a还初始化并处于暂停初始化状态,直接取B.a的当前值,不再等待B.a初始化.
- final,静态常量其实是遵循普通静态变量的初始化的,但是在编译时,编译器会将不可变的常量值在使用的地方替换掉.可以用Java反编译工具查看.
static数据的初始化
加上static限定的字段,是所谓的类字段,也就是说这个字段的拥有者不是对象而是类。无论创建多少对象,static数据都只有一份。
类内总是先初始化static字段,再初始化一般字段。接着初始化构造器。但是如果不创建这个类的对象,那这个对象是不会进行初始化的,并且只执行一次。
如下面的代码,在StaticInitialization类中,先初始化staticTabletable=newTable();,然后才去初始化Table对象,不然是不会被初始化的。
classBowl{ Bowl(intmarker){ print("Bowl("+marker+")"); } voidf1(intmarker){ print("f1("+marker+")"); } } classTable{ staticBowlbowl1=newBowl(1); Table(){ print("Table()"); bowl2.f1(1); } voidf2(intmarker){ print("f2("+marker+")"); } staticBowlbowl2=newBowl(2); } classCupboard{ Bowlbowl3=newBowl(3); staticBowlbowl4=newBowl(4); Cupboard(){ print("Cupboard()"); bowl4.f1(2); } voidf3(intmarker){ print("f3("+marker+")"); } staticBowlbowl5=newBowl(5); } publicclassStaticInitialization{ publicstaticvoidmain(String[]args){ print("CreatingnewCupboard()inmain"); newCupboard(); print("CreatingnewCupboard()inmain"); newCupboard(); table.f2(1); cupboard.f3(1); } staticTabletable=newTable(); staticCupboardcupboard=newCupboard(); }
输出:
Bowl(1) Bowl(2) Table() f1(1) Bowl(4) Bowl(5) Bowl(3) Cupboard() f1(2) CreatingnewCupboard()inmain Bowl(3) Cupboard() f1(2) CreatingnewCupboard()inmain Bowl(3) Cupboard() f1(2) f2(1) f3(1)
显示的静态初始化(也就是静态块)
把多个初始化语句包在一个static花括号里,叫做静态块,其实就是把多个static合在一起写了,本质是一样的。只有首次创建对象或者首次访问类的字段时才会执行,而且仅仅一次。
classCup{ Cup(intmarker){ print("Cup("+marker+")"); } voidf(intmarker){ print("f("+marker+")"); } } classCups{ staticCupcup1; staticCupcup2; static{ cup1=newCup(1); cup2=newCup(2); } Cups(){ print("Cups()"); } } publicclassExplicitStatic{ publicstaticvoidmain(String[]args){ print("Insidemain()"); Cups.cup1.f(99);//(1) } //staticCupscups1=newCups();//(2) //staticCupscups2=newCups();//(2) }
输出:
Insidemain() Cup(1) Cup(2) f(99)
非静态实例初始化
这个没什么好讲的,就是普通初始化,按顺序执行,可以多次执行。
classMug{ Mug(intmarker){ print("Mug("+marker+")"); } voidf(intmarker){ print("f("+marker+")"); } } publicclassMugs{ Mugmug1; Mugmug2; { mug1=newMug(1); mug2=newMug(2); print("mug1&mug2initialized"); } Mugs(){ print("Mugs()"); } Mugs(inti){ print("Mugs(int)"); } publicstaticvoidmain(String[]args){ print("Insidemain()"); newMugs(); print("newMugs()completed"); newMugs(1); print("newMugs(1)completed"); } }
Insidemain() Mug(1) Mug(2) mug1&mug2initialized Mugs() newMugs()completed Mug(1) Mug(2) mug1&mug2initialized Mugs(int) newMugs(1)completed