Java中static静态变量的初始化完全解析

2024-03-17 00:07:04 323

静态变量初始化顺序
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的。

如果你不明白是为什么会输出上面的结果,那么我来告诉你。

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

Java中static静态变量的初始化完全解析

热门推荐

随机推荐