静态变量初始化顺序

1. 代码

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 12.0px "Helvetica Neue"; color: #454545 }
p.p2 { margin: 0.0px 0.0px 0.0px 0.0px; font: 12.0px "Helvetica Neue"; color: #454545; min-height: 14.0px }
span.s1 { font: 12.0px ".PingFang SC" }
span.Apple-tab-span { white-space: pre }

public class A {

public static int num01 = B.num02;

public static A instance01_a  = new A("A的对象"); // 打印输出二:执行构造函数 A

public static final int finalInt =  (int) (Math.random()*100);

public static B instance02_b = new B("B的对象"); // 打印输出三:执行构造函数 B

public static final String finalStr = "finalStr";

public static final Integer finalInteger = new Integer(10);

public static int num02 = 1;

public static C instance03_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.num01 = "+A.num01);

System.out.println("A::A, B.num02 = "+B.num02);

System.out.println("A::A, B.instance_a = "+B.instance_a);

System.out.println("------------end A::A------------");

}

public static void main(String[] args) {

System.out.println("main, A.num01 = "+ A.num01);

System.out.println("main, B.num01 = "+B.num01);

System.out.println("main, C.instance = "+C.instance_a); // 打印输出四:构造函数 A

}

}

class B{

public static int num01 = A.num02;

public static A instance_a = new A("A的对象");  // 打印输出一:执行构造函数 A

public static int num02 = 1;

public B(String from){

System.out.println("------------start B::B------------");

System.out.println("B::B, from = "+from);

System.out.println("B::B, B.num02 = "+num02);

System.out.println("B::B, A.num02 = "+A.num02);

System.out.println("B::B, A.instance02_b = "+A.instance02_b);

System.out.println("B::B, A.instance01_a = " +A.instance01_a);

System.out.println("B::B, A.finalInt = "+A.finalInt);

System.out.println("B::B, A.finalStr = "+A.finalStr);

System.out.println("B::B, A.finalInteger = "+A.finalInteger);

System.out.println("------------end B::B------------");

}

}

class C{

public static final A instance_a = new A("A的对象");

}

2. 打印结果:

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 11.0px Monaco; color: #efefef }

------------begin A::A------------

A::A, from = A的对象

A::A, A.num01 = 0

A::A, B.num02 = 0

A::A, B.instance_a = null

------------end A::A------------

------------begin A::A------------

A::A, from = A的对象

A::A, A.num01 = 1

A::A, B.num02 = 1

A::A, B.instance_a = [email protected]

------------end A::A------------

------------start B::B------------

B::B, from = B的对象

B::B, B.num02 = 1

B::B, A.num02 = 0

B::B, A.instance02_b = null

B::B, A.instance01_a = [email protected]

B::B, A.finalInt = 97

B::B, A.finalStr = finalStr

B::B, A.finalInteger = null

------------end B::B------------

main, A.num01 = 1

main, B.num01 = 0

------------begin A::A------------

A::A, from = A的对象

A::A, A.num01 = 1

A::A, B.num02 = 1

A::A, B.instance_a = [email protected]

------------end A::A------------

main, C.instance = [email protected]

3.初始化过程分析:(只分析打印的第一个构造函数中)

(1)只有主动请求一个类时,该类才会初始化。初始化仅包括静态变量、函数等静态部分

(2)继承关系时先初始化父类,再初始化子类

(3)静态变量会按照声明顺序,依次声明并设置该类型的默认值,(此时不赋值为初始化的值)

(4)声明完毕后,再按照声明顺序依次设置为初始化的值,如果没有初始化则跳过

(5)当初始化到A.num01 = B.num02时,暂停初始化A.num01,设置当前类为B,跳转到步骤3并执行

(6)当初始化到 B.instance_a = new A("A的对象")时,暂停初始化B.instance_a, 实例化A并赋值给B.instance_a

(7)(接上)实例化A的过程中,需要B.num02, B.num02的当前值为默认值0。 【B.instance_a的值,但是后者还未初始化并处于暂停状态】; B.instance_a也是如此,当前值为null。

时间: 2024-11-10 17:40:59

静态变量初始化顺序的相关文章

java 静态变量初始化顺序

public class Elvis { public static final Elvis INSTANCE = new Elvis(); private final int beltSize; private static final int CURRENT_YEAR = Calendar.getInstance().get(Calendar.YEAR); private Elvis() { beltSize = CURRENT_YEAR - 1930; } public int beltS

Java静态方法,静态变量,初始化顺序

1. 静态方法: 成员变量分为实例变量和静态变量.其中实例变量属于某一个具体的实例,必须在类实例化后才真正存在,不同的对象拥有不同的实例变量.而静态变量被该类所有的对象公有(相当于全局变量),不需要实例化就已经存在. 方法也可分为实例方法和静态方法.其中,实例方法必须在类实例化之后通过对象来调用,而静态方法可以在类实例化之前就使用.与成员变量不同的是:无论哪种方法,在内存中只有一份——无论该类有多少个实例,都共用同一个方法. 实例方法的调用: ClassA a = new ClassA();  

【细说Java】Java变量初始化顺序

Java的变量初始化顺序,对这里一直似懂非懂,面试的时候也经常被问到,但答的一直不好,现在整理记录一下,以后忘记了可以来看看. 程序分为两个部分,第一个部分不考虑继承,第二个部分考虑继承: (1)不考虑继承的情况 代码如下: public class JavaTest { public JavaTest() { System.out.println("执行JavaTest构造方法1"); } public JavaTest(String param) { System.out.prin

调整static变量初始化顺序的一个办法

// wrap the LaunchDir variable in a function to work around static/global initialization order static FString& GetWrappedLaunchDir() { static FString LaunchDir; return LaunchDir; } 在ue4中看到这么一段代码,注释有点意思 不同cpp文件里的全局static变量初始化顺序是不可控的 FString显然会依赖很多内存分配

duilib lib库静态变量初始化问题

Redrain提供的duilib https://github.com/redrains/DuiLib_Redrain 可编译得到静态库,但是存在一个问题:如果将窗口对象作为全局变量使用时,它会依赖于uilib库中的一些全局变量,由于没有确保lib库的变量初始化先于工程中的全局变量,从而导致崩溃. 应该再uilib代码中添加 #pragma init_seg(lib) 以确保lib库中的全局变量先初始化

C++全局和静态变量初始化

转自:http://www.cnblogs.com/zhenjing/archive/2010/10/15/1852116.html 对于C语言的全局和静态变量,不管是否被初始化,其内存空间都是全局的:如果初始化,那么初始化发生在任何代码执行之前,属于编译期初始化.由于内置变量无须资源释放操作,仅需要回收内存空间,因此程序结束后全局内存空间被一起回收,不存在变量依赖问题,没有任何代码会再被执行! C++引入了对象,这给全局变量的管理带领新的麻烦.C++的对象必须有构造函数生成,并最终执行析构操作

4、 C++函数内的静态变量初始化以及线程安全问题

原文:https://www.cnblogs.com/zxjan/p/3538911.html 1. 如果是编译时和加载时初始化, 是不会存在线程安全这个issue的; 因为这两种初始化一定发生在Main函数执行之前, 这个时候尚未进入程序运行空间; 而这些初始化一定是在单线程环境下操作的!  --  都是在执行C Runtime的startup代码中的void mainCRTStartup(void)函数时所在的OS系统加载程序时的主线程空间上发生的! 2. 如果是运行时初始化, 因为无法保证

【java解惑】final域变量初始化顺序

如下所示代码: public class Example049 { private final int overtime; public static final Example049 INSTANCE = new Example049();//1 private static final int CURRENT_YEAR = Calendar.getInstance().get( Calendar.YEAR);//2 private Example049() { overtime = CURR

转:Java的一道面试题----静态变量初始化过程

public class Test{ private static Test tester = new Test(); //step 1 private static int count1; //step 2 private static int count2 = 2; //step 3 public Test(){ //step 4 count1++; count2++; System.out.println("" + count1 + count2); } public stati