Static变量和实例变量的初始化顺序问题

最新推荐文章于 2023-10-13 16:57:44 发布
最新推荐文章于 2023-10-13 16:57:44 发布
阅读量335 收藏
点赞数
分类专栏： Tips 文章标签： Java 编程 C C++ C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DLevin/article/details/83724227
版权

问题重现

让我们先来看一下以下的程序：

public class StaticInitSequence {
	//-------------------Static fields-------------------
	private static int staticIntVar = 10;
	private static int staticComputeIntVar = (int)(Math.random() * 10);
	private static String staticStrVar = "Static field init(before)";
	private static Object staticRefVar = new Object();
	
	static {
		staticIntVar = 20;
		staticStrVar = "Static block init(before)";
		staticAfterIntVar = 40;
		staticAfterStrVar = "Static block init(after)";
	}
	
	private static int staticAfterIntVar = 30;
	private static String staticAfterStrVar = "Static field init(after)";
	
	//---------------------Instance fields----------------
	private int fieldIntVar = 100;
	private int fieldComputeIntVar = (int)(Math.random() * 100);
	private String fieldStrVar = "Instance field init(before)";
	
	public StaticInitSequence() {
		fieldIntVar = 200;
		fieldStrVar = "Constructor field init(before)";
		
		fieldAfterIntVar = 400;
		fieldAfterStrVar = "Constructor field init(after)";
	}
	
	private int fieldAfterIntVar = 300;
	private String fieldAfterStrVar = "Instance field init(after)";
	
	public void print() {
		System.out.println("----------------Static Fields------------");
		System.out.println("staticIntVar: " + staticIntVar);
		System.out.println("staticComputeIntVar: " + staticComputeIntVar);
		System.out.println("staticStrVar: " + staticStrVar);
		System.out.println("staticRefVar: " + staticRefVar);
		System.out.println("staticAfterIntVar: " + staticAfterIntVar);
		System.out.println("staticAfterStrVar: " + staticAfterStrVar);
		
		System.out.println("-----------------Instance Fields---------");
		System.out.println("fieldIntVar : " + fieldIntVar);
		System.out.println("fieldComputeIntVar : " + fieldComputeIntVar);
		System.out.println("fieldStrVar : " + fieldStrVar);
		System.out.println("fieldAfterIntVar : " + fieldAfterIntVar);
		System.out.println("fieldAfterStrVar : " + fieldAfterStrVar);
	}
}

 

如果我们调用以上类的print()方法（new StaticInitSequence().print()），会有什么样的结果呢？

我自认为，直接对一个字段初始化是编译器提供支持的一种编程方式，这种编程方式可以提高代码的可读性，因为用户可以直接知道一个字段的初始值，而不用到构造函数或者静态语句块里面去找。在Java中，实际编译后的二进制文件中，所有的字段初始化语句都放在了初始化函数中（类（静态）初始化函数（<clinit>）或者实例初始化（构造函数/<init>）函数）。因此在我的逻辑思维中，在源代码中，初始化函数应该可以改变字段初始化中的值，这样还就可以在字段初始化中提供一个初始值，而在初始化函数中根据需要改变它。然而另我感到意外的是Java中只有实例初始化机制是这样实现的，而静态字段初始化中没有实现这种机制（在C#中不管实例初始化和静态初始化都实现了这种机制），静态字段初始化的顺序是完全根据源代码中定义顺序来初始化的；从耦合的角度，这就是一个顺序耦合的典型。不知道为什么Java要这样实现，是否它有其他方面的问题的考虑？亦或是Java设计者或者Java编译器设计者的一个失误？不管怎么样，用sun的javac编译出来的以上程序的运行结果如下：

----------------Static Fields------------

staticIntVar: 20

staticComputeIntVar: 7

staticStrVar: Static block init(before)

staticRefVar: java.lang.Object@14318bb

staticAfterIntVar: 30

staticAfterStrVar: Static field init(after)

-----------------Instance Fields---------

fieldIntVar : 200

fieldComputeIntVar : 8

fieldStrVar : Constructor field init(before)

fieldAfterIntVar : 400

fieldAfterStrVar : Constructor field init(after)

 

问题解释：

从以上程序生成的二进制代码就可以很好的解释以上的结果：

<clinit>:

         //staticIntVar = 10

     0  bipush 10

     2  putstatic org.levin.insidejvm.miscs.staticinit.StaticInitSequence.staticIntVar : int [22]

       // staticComputeIntVar = (int)(Math.random() * 10)

     5  invokestatic java.lang.Math.random() : double [24]

     8  ldc2_w <Double 10.0> [30]

    11  dmul

12  d2i

13  putstatic org.levin.insidejvm.miscs.staticinit.StaticInitSequence.staticComputeIntVar : int [32]

//staticStrVar = “Static field init(before)”

    16  ldc <String "Static field init(before)"> [34]

18  putstatic org.levin.insidejvm.miscs.staticinit.StaticInitSequence.staticStrVar : java.lang.String [36]

//staticRefVar = new Object();

    21  new java.lang.Object [3]

    24  dup

    25  invokespecial java.lang.Object() [38]

28  putstatic org.levin.insidejvm.miscs.staticinit.StaticInitSequence.staticRefVar : java.lang.Object [41]

//staticIntVar = 20

    31  bipush 20

33  putstatic org.levin.insidejvm.miscs.staticinit.StaticInitSequence.staticIntVar : int [22]

//staticStrVar = “Static block init(before)”

    36  ldc <String "Static block init(before)"> [43]

38  putstatic org.levin.insidejvm.miscs.staticinit.StaticInitSequence.staticStrVar : java.lang.String [36]

//staticAfterIntVar = 40

    41  bipush 40

43  putstatic org.levin.insidejvm.miscs.staticinit.StaticInitSequence.staticAfterIntVar : int [45]

//staticAfterStr = “Statci block init(after)”

    46  ldc <String "Static block init(after)"> [47]

48  putstatic org.levin.insidejvm.miscs.staticinit.StaticInitSequence.staticAfterStrVar : java.lang.String [49]

//staticAfterIntVar = 30

    51  bipush 30

53  putstatic org.levin.insidejvm.miscs.staticinit.StaticInitSequence.staticAfterIntVar : int [45]

//staticAfterStrVar = “Static field init(after)”

    56  ldc <String "Static field init(after)"> [51]

    58  putstatic org.levin.insidejvm.miscs.staticinit.StaticInitSequence.staticAfterStrVar : java.lang.String [49]

61  return

 

<init>:

       //invoke base constructor

     0  aload_0 [this]

     1  invokespecial java.lang.Object() [38]

     4  aload_0 [this]

       //fieldIntVar = 100

     5  bipush 100

     7  putfield org.levin.insidejvm.miscs.staticinit.StaticInitSequence.fieldIntVar : int [55]

       //fieldComputeIntVar = (int)(Math.random() * 100)

    10  aload_0 [this]

    11  invokestatic java.lang.Math.random() : double [24]

    14  ldc2_w <Double 100.0> [57]

    17  dmul

    18  d2i

19  putfield org.levin.insidejvm.miscs.staticinit.StaticInitSequence.fieldComputeIntVar : int [59]

//fieldStrVar = “Instance field init(before)”

    22  aload_0 [this]

    23  ldc <String "Instance field init(before)"> [61]

25  putfield org.levin.insidejvm.miscs.staticinit.StaticInitSequence.fieldStrVar : java.lang.String [63]

//fieldAfterIntVar = 300

    28  aload_0 [this]

    29  sipush 300

32  putfield org.levin.insidejvm.miscs.staticinit.StaticInitSequence.fieldAfterIntVar : int [65]

//fieldAfterStrVar = “Instance field init(after)”

    35  aload_0 [this]

    36  ldc <String "Instance field init(after)"> [67]

38  putfield org.levin.insidejvm.miscs.staticinit.StaticInitSequence.fieldAfterStrVar : java.lang.String [69]

//fieldIntVar = 200

    41  aload_0 [this]

    42  sipush 200

45  putfield org.levin.insidejvm.miscs.staticinit.StaticInitSequence.fieldIntVar : int [55]

//fieldStrVar = “Constructor field init(before)”

    48  aload_0 [this]

    49  ldc <String "Constructor field init(before)"> [71]

51  putfield org.levin.insidejvm.miscs.staticinit.StaticInitSequence.fieldStrVar : java.lang.String [63]

//fieldAfterIntVar = 400

    54  aload_0 [this]

    55  sipush 400

58  putfield org.levin.insidejvm.miscs.staticinit.StaticInitSequence.fieldAfterIntVar : int [65]

//fieldAfterStrVar = “Constructor field init(after)”

    61  aload_0 [this]

    62  ldc <String "Constructor field init(after)"> [73]

    64  putfield org.levin.insidejvm.miscs.staticinit.StaticInitSequence.fieldAfterStrVar : java.lang.String [69]

67  return

 

问题延伸

在这里，细心的人可能还会想到另外一个问题，如果StaticInitSequence类还有父类，并且父类中同同时有静态成员初始化，静态语句块初始化，实例成员初始化，构造函数初始化，那会这样的顺序会是怎么样的呢？在Java中，保证父类的初始化要早于子类的初始化，因而如果有父类存在的话，一定是先父类初始化做好以后才做子类的初始化（这一点和C#又有略微的不同，在C#中，子类的字段初始化语句要早于父类的初始化语句和构造函数），并且是先静态初始化再实例初始化。

 

 

DLevin
关注
专栏目录
java静态变量需要初始化吗_» Java静态变量初始化顺序浅谈
weixin_30631569的博客
02-27 994
Java 类初始化顺序在网上已经有很多文章了,这里不再谈那么多,仅仅谈下Java静态变量的初始化顺序,如果你是Java高手,并且自认为对这个顺序已经掌握到了炉火纯青的境界,请忽视这篇文章.前天看了Y.BOY对AS程序员的《关于初始化静态变量的一些思考》,让我感觉这个东西很奇妙,他的问题也是从JAVA来的.然后我就做了些测试,发现与我想的很不一样.而且Java与AS的也不一样.今天就先将关于Java...
深入理解final变量的初始化
09-05
- **实例变量**：实例变量的初始化顺序与它们在类声明中的顺序一致，同时考虑初始化块。在`InitOrder`的例子中，`c1`的初始化块在`d1`之前，所以`c1`先被初始化。 5. **错误和限制**： - 当尝试在初始化块中引用...
静态(static)变量的初始化
weixin_33705053的博客
02-22 124
公司为了记录我们都上了什么网，将网络改成需要使用代理才能上网。具体表现就是上网前要输入账号和密码。这样我们那些爬虫代码也要跟着改写了。Uri target = new Uri(sUrl); HttpWebRequest resquest = (HttpWebRequest)WebRequest.Create(target); ProxySetting(resquest); …… //设置代理...
java static 初始化顺序_Java静态方法,静态变量,初始化顺序
weixin_34170028的博客
02-13 742
1. 静态方法：成员变量分为实例变量和静态变量。其中实例变量属于某一个具体的实例，必须在类实例化后才真正存在，不同的对象拥有不同的实例变量。而静态变量被该类所有的对象公有(相当于全局变量)，不需要实例化就已经存在。方法也可分为实例方法和静态方法。其中，实例方法必须在类实例化之后通过对象来调用，而静态方法可以在类实例化之前就使用。与成员变量不同的是：无论哪种方法，在内存中只有一份——无论该类有多少个...
static变量初始化
chivalry
06-01 6917
1.在C++中，全局static变量和class的static成员变量在main函数之前初始化，main函数之后销毁 2. 函数内部的局部static变量在该函数第一次被调用时初始化，在main函数之后销毁 3.对于static数据即使是函数内部的对象则存放在全局数据区，全局数据区的数据并不会因为函数的退出就将空间释放。 #include using namespace std;
java中的静态变量、静态方法与静态代码块详解与初始化顺序
weixin_30938149的博客
01-04 147
我们知道类的生命周期分为装载、连接、初始化、使用和卸载的五个过程。其中静态代码在类的初始化阶段被初始化。 而非静态代码则在类的使用阶段（也就是实例化一个类的时候）才会被初始化。 静态变量 可以将静态变量理解为类变量（与对象无关），而实例变量则属于一个特定的对象。 静态变量有两种情况： 静态变量是基本数据类型，这种情况下在类的外部不...
Java中static静态变量的初始化完全解析
09-02
了解静态变量的初始化顺序对于理解和避免潜在的编程陷阱至关重要。 ### 静态变量初始化的基本规则： 1. **默认初始化**：当类被加载时，静态变量首先会被赋予其数据类型的默认值。例如，`int`类型的静态变量会被...
浅谈Java变量的初始化顺序详解
09-05
总结一下Java变量初始化顺序的要点： 1. **静态变量与静态初始化块**：首先按照在类中定义的顺序初始化所有静态变量和执行静态初始化块。这是在类被加载到内存时发生的，与对象创建无关。 2. **非静态变量与初始化...
Java类变量和成员变量初始化过程的应用介绍
09-05
总结一下，Java中类变量和成员变量的初始化顺序是这样的： 1. 类变量按照定义顺序进行静态初始化。 2. 创建对象时，先执行实例初始化块，然后调用构造函数，构造函数中的初始化会覆盖实例初始化块中已初始化的值。 ...
静态变量、实例变量初始化时机，以及子类隐藏父类成员时，创建子类对象的一些问题
可爱的男孩子的博客
09-23 356
静态变量、实例变量初始化时机，以及子类隐藏父类成员时，创建子类对象的一些问题 代码： package acx; public class TestClass { public String count="testclass";//实例变量 public static TestClass testClass=getInstence(); publi
Java中的static变量、方法、代码块初始化执行顺序
weixin_34209406的博客
11-14 414
Java中的static变量,方法,代码块 1、static变量　按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是： 对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类...
java静态变量初始化几次_Java初始化静态变量的时间顺序
weixin_28941715的博客
02-13 883
1. 开始吧！今天，我们来探讨交流下静态变量初始化过程。Java虚拟机在类加载期间也同样遵循这个过程。2. 初始化过程在较高的层次上，JVM执行以下步骤：首先，加载并链接类。然后，这个过程的“初始化”阶段处理静态变量初始化。最后，调用与类关联的main方法。在接下来的讨论中，我们来探索下类变量初始化。3. 类变量在Java中，静态变量也称为类变量。也就是说，它们属于一个类，而不是一个特定的实例。因...
Static 变量的初始化
长豆角
01-25 1435
<br /> <br />这是一个基础性的问题，写在这里只是为了加深自己的印象。<br />在类中所有的static变量必须在类定义的时候进行初始化，不能在内联函数（比如说构造函数）中初始化。<br /> <br />#include <iostream> using namespace std; class staticDemo { static int x; static int y; public: void print() const { cou
静态变量初始化 && 类实例初始化
探索新世界
02-12 296
[color=red]【本文整合多篇网文+验证扩展而成】[/color] [b]1. 静态变量(块)初始化[/b] [b]1.1 大概了解Java虚拟机初始化的原理[/b] JVM通过加装、连接和初始化一个Java类，使该类可以被正在运行的Java程序所使用。装载和连接必须在初始化之前就要完成。Java类型的生命周期： [img]http://dl2.iteye.com/uplo...
C++中static变量的初始化
最新发布
duskymountain的博客
10-13 5460
如果采用静态初始化，是在编译时完成的初始化，即是在main()函数执行前由运行时调用相应的代码进行初始化的。· 如果采用静态初始化，是在加载时完成的初始化，即是在main()函数执行前由运行时调用相应的代码进行初始化的。· 如果采用静态初始化，是在加载时完成的初始化，会在main()函数执行前由运行时调用相应的代码进行初始化的；· 如果采用动态初始化，也是在加载时调用的，会在main()函数执行前由运行时调用相应的代码进行初始化的。同时，在加载期，是线程安全的。调用相应的代码进行初始化的。
c语言static变量初始化
weixin_43479963的博客
10-30 4314
《程序员面试笔试宝典》第123页，举了个例子 #include <stdio.h> void fun(int i) { static int value=i++; printf("%d\n",value); } int main() { fun(0); func(1); fun(2); return 0; } 书中写道:程序输出结果为 0 0 0 作者原意是想表明 static int value=i++;是变量value由于static的修饰，只会定义一次value变量，并且
static变量初始化　静态块
a854507555的博客
02-16 585
static初始化只有在必要的时候才会进行。如果不创建一个 Table 对象，而且永远都不引用Table.b1 或Table.b2，那么 static Bowl b1 和b2 永远都不会创建。然而，只有在创建第一个Table 对象之后（或者发生了第一次static 访问），它们才会创建。在那以后，static 对象不会重新初始化。初始化的顺序是首先static（如果它们尚未由前一次对象创建过程初始
Java类与实例变量初始化顺序解析
3. **变量初始化顺序** 在类内部，无论变量声明的位置如何，变量的初始化顺序遵循它们在源代码中出现的顺序。这意味着，即使变量定义分散在不同的位置，它们也会按照在代码中出现的顺序进行初始化。 4. **构造器的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值