正文

java代码初始化的作用 java代码初始化的作用是什么

IP云
IP云V管理员/5 阅读
03/23
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

java 初始化是做什么的?

关于Java初始化java代码初始化的作用，有多文章都用java代码初始化的作用了很大篇幅的介绍。经典的更是用了专门的

一章来介绍Java初始化。但在大量有代码实例后面，感觉上仍然没有真正深入到初始化的本质。

本文以作者对JVM的理解和自己的经验，对Java的初始化做一个比深入的说明，由于作者有水平限制，

以及JDK各实现版本的变化，可能仍然有不少错误和缺点。欢迎行家高手赐教。

要深入了解Java初始化，我们无法知道从程序流程上知道JVM是按什么顺序来执行的。了解JVM的执行

机制和堆栈跟踪是有效的手段。可惜的是，到目前为止。JDK1。4和JDK1。5在javap功能上却仍然存在

着BUG。所以有些过程我无法用实际的结果向你证明两种相反的情况（但我可以证明那确实是一个BUG）

(第三版)在第四章一开始的时候,这样来描述Java的初始化工作:

以下译文原文:

可以这样认为,每个类都有一个名为Initialize()的方法,这个名字就暗示了它得在使用之前调用,不幸

的是,这么做的话,用户就得记住要调用这个方法,java类库的设计者们可以通过一种被称为构造函数的

特殊方法,来保证每个对象都能得到被始化.如果类有构造函数,那么java就会在对象刚刚创建,用户还来

不及得到的时候,自动调用那个构造函数,这样初始化就有保障了。

我不知道原作者的描述和译者的理解之间有多大的差异,结合全章,我没有发现两个最关键的字""

和""。至少说明原作者和译者并没有真正说明JVM在初始化时做了什么,或者说并不了解JVM的初始化

内幕,要不然明明有这两个方法,却为什么要认为有一个事实上并不存在的"Initialize()"方法呢?

""和""方法在哪里？

这两个方法是实际存在而你又找不到的方法，也许正是这样才使得一些大师都犯晕。加上jdk实现上的一

些BUG，如果没有深入了解，真的让人摸不着北。

现在科学体系有一个奇怪的现象，那么庞大的体系最初都是建立在一个假设的基础是，假设1是正确的，

由此推导出2，再继续推导出10000000000。可惜的是太多的人根本不在乎2-100000000000这样的体系都

是建立在假设1是正确的基础上的。我并不会用“可以这样认为”这样的假设，我要确实证明""

和""方法是真真实实的存在的：

packagedebug;

publicclassMyTest{

staticinti=100/0;

publicstaticvoidmain(String[]args){

Ssytem.out.println("Hello,World!");

}

}

执行一下看看,这是jdk1.5的输出：

java.lang.ExceptionInInitializerError

Causedby:java.lang.ArithmeticException:/byzero

atdebug.MyTest.(Test.java:3)

Exceptioninthread"main"

请注意，和其它方法调用时产生的异常一样，异常被定位于debug.MyTest的.

再来看：

packagedebug;

publicclassTest{

Test(){

inti=100/0;

}

publicstaticvoidmain(String[]args){

newTest();

}

}

jdk1.5输入：

Exceptioninthread"main"java.lang.ArithmeticException:/byzero

atdebug.Test.(Test.java:4)

atdebug.Test.main(Test.java:7)

JVM并没有把异常定位在Test()构造方法中，而是在debug.Test.。

当我们看到了这两个方法以后，我们再来详细讨论这两个“内置初始化方法”（我并不喜欢生造一些

非标准的术语，但我确实不知道如何规范地称呼他们）。

内置初始化方法是JVM在内部专门用于初始化的特有方法，而不是提供给程序员调用的方法，事实上

“”这样的语法在源程序中你连编译都无法通过。这就说明，初始化是由JVM控制而不是让程序员

来控制的。

类初始化方法：

我没有从任何地方了解到的cl是不是class的简写，但这个方法确实是用来对“类”进行初

始化的。换句话说它是用来初始化static上下文的。

在类装载（load）时，JVM会调用内置的方法对类成员和静态初始化块进行初始化调用。它们

的顺序按照源文件的原文顺序。

我们稍微增加两行static语句：

packagedebug;

publicclassTest{

staticintx=0;

staticStrings="123";

static{

Strings1="456";

if(1==1)

thrownewRuntimeException();

}

publicstaticvoidmain(String[]args){

newTest();

}

}

然后进行反编译：

javap-cdebug.Test

Compiledfrom"Test.java"

publicclassdebug.Testextendsjava.lang.Object{

staticintx;

staticjava.lang.Strings;

publicdebug.Test();

Code:

0:aload_0

1:invokespecial#1;//Methodjava/lang/Object."":()V

4:return

publicstaticvoidmain(java.lang.String[]);

Code:

0:new#2;//classdebug/Test

3:dup

4:invokespecial#3;//Method"":()V

7:pop

8:return

static{};

Code:

0:iconst_0

1:putstatic#4;//Fieldx:I

4:ldc#5;//String123

6:putstatic#6;//Fields:Ljava/lang/String;

9:ldc#7;//String456

11:astore_0

12:new#8;//classjava/lang/RuntimeException

15:dup

16:invokespecial#9;//Methodjava/lang/RuntimeException."":()V

19:athrow

}

这里，我们不得不说，JDK在javap功能上的实现有一个BUG。static段的16标号，那里标识了异常

的位置发生在""方法中，而实际上这段程序运行时的输出却是：

java.lang.ExceptionInInitializerError

Causedby:java.lang.RuntimeException

atdebug.Test.(Test.java:8)

Exceptioninthread"main"

但我们总可以明白，类初始化正是按照源文件中定义的原文顺序进行。先是声明

staticintx;

staticjava.lang.Strings;

然后对intx和Strings进行赋值：

0:iconst_0

1:putstatic#4;//Fieldx:I

4:ldc#5;//String123

6:putstatic#6;//Fields:Ljava/lang/String;

执行初始化块的Strings1="456";生成一个RuntimeException抛

9:ldc#7;//String456

11:astore_0

12:new#8;//classjava/lang/RuntimeException

15:dup

16:invokespecial#9;//Methodjava/lang/RuntimeException."":()V

19:athrow

要明白的是，""方法不仅是类初始化方法，而且也是接口初始化方法。并不是所以接口

的属性都是内联的，只有直接赋常量值的接口常量才会内联。而

[publicstaticfinal]doubled=Math.random()*100;

这样的表达式是需要计算的，在接口中就要由""方法来初始化。

下面我们再来看看实例初始化方法""

""用于对象创建时对对象进行初始化，当在HEAP中创建对象时，一旦在HEAP分配了空间。最

先就会调用""方法。这个方法包括实例变量的赋值（声明不在其中）和初始化块，以及构造

方法调用。如果有多个重载的构造方法，每个构造方法都会有一个对应的""方法。

同样，实例变量和初始化块的顺序也是按源文件的原文顺序执行，构造方法中的代码在最后执行：

packagedebug;

publicclassTest{

intx=0;

Strings="123";

{

Strings1="456";

//if(1==1)

//thrownewRuntimeException();

}

publicTest(){

Stringss="789";

}

publicstaticvoidmain(String[]args){

newTest();

}

}

javap-cdebug.Test的结果：

Compiledfrom"Test.java"

publicclassdebug.Testextendsjava.lang.Object{

intx;

java.lang.Strings;

publicdebug.Test();

Code:

0:aload_0

1:invokespecial#1;//Methodjava/lang/Object."":()V

4:aload_0

5:iconst_0

6:putfield#2;//Fieldx:I

9:aload_0

10:ldc#3;//String123

12:putfield#4;//Fields:Ljava/lang/String;

15:ldc#5;//String456

17:astore_1

18:ldc#6;//String789

20:astore_1

21:return

publicstaticvoidmain(java.lang.String[]);

Code:

0:new#7;//classdebug/Test

3:dup

4:invokespecial#8;//Method"":()V

7:pop

8:return

}

如果在同一个类中，一个构造方法调用了另一个构造方法，那么对应的""方法就会调用另一

个""，但是实例变量和初始化块会被忽略，否则它们就会被多次执行。

packagedebug;

publicclassTest{

Strings1=rt("s1");

Strings2="s2";

publicTest(){

s1="s1";

}

publicTest(Strings){

this();

if(1==1)thrownewRuntime();

}

Stringrt(Strings){

returns;

}

publicstaticvoidmain(String[]args){

newTest("");

}

}

反编译的结果：

Compiledfrom"Test.java"

publicclassdebug.Testextendsjava.lang.Object{

java.lang.Strings1;

java.lang.Strings2;

publicdebug.Test();

Code:

0:aload_0

1:invokespecial#1;//Methodjava/lang/Object."":()V

4:aload_0

5:aload_0

6:ldc#2;//Strings1

8:invokevirtual#3;//Methodrt:(Ljava/lang/String;)Ljava/lang/String;

11:putfield#4;//Fields1:Ljava/lang/String;

14:aload_0

15:ldc#5;//Strings2

17:putfield#6;//Fields2:Ljava/lang/String;

20:aload_0

21:ldc#2;//Strings1

23:putfield#4;//Fields1:Ljava/lang/String;

26:return

publicdebug.Test(java.lang.String);

Code:

0:aload_0

1:invokespecial#7;//Method"":()V

4:new#8;//classjava/lang/RuntimeException

7:dup

8:invokespecial#9;//Methodjava/lang/RuntimeException."":()V

11:athrow

java.lang.Stringrt(java.lang.String);

Code:

0:aload_1

1:areturn

publicstaticvoidmain(java.lang.String[]);

Code:

0:new#10;//classdebug/Test

3:dup

4:ldc#11;//String

6:invokespecial#12;//Method"":(Ljava/lang/String;)V

9:pop

10:return

}

我们再一次看到了javap实现的bug，虽然有一个"":(Ljava/lang/String;)V签名可以说明

每个构造方法对应一个不同,但Runtime异常仍然被定位到了""()V的方法中：

invokespecial#8;//Methodjava/lang/RuntimeException."":()V,而在main方法中的

调用却明明是"":(Ljava/lang/String;)V.

但是我们看到，由于Test(Strings)调用了Test();所以"":(Ljava/lang/String;)V不再对

实例变量和初始化块进次初始化：

publicdebug.Test(java.lang.String);

Code:

0:aload_0

1:invokespecial#7;//Method"":()V

4:new#8;//classjava/lang/RuntimeException

7:dup

8:invokespecial#9;//Methodjava/lang/RuntimeException."":()V

11:athrow

而如果两个构造方法是相互独立的，则每个构造方法调用前都会执行实例变量和初始化块的调用：

packagedebug;

publicclassTest{

Strings1=rt("s1");

Strings2="s2";

{

Strings3="s3";

}

publicTest(){

s1="s1";

}

publicTest(Strings){

if(1==1)

thrownewRuntimeException();

}

Stringrt(Strings){

returns;

}

publicstaticvoidmain(String[]args){

newTest("");

}

}

反编译的结果：

Compiledfrom"Test.java"

publicclassdebug.Testextendsjava.lang.Object{

java.lang.Strings1;

java.lang.Strings2;

publicdebug.Test();

Code:

0:aload_0

1:invokespecial#1;//Methodjava/lang/Object."":()V

4:aload_0

5:aload_0

6:ldc#2;//Strings1

8:invokevirtual#3;//Methodrt:(Ljava/lang/String;)Ljava/lang/String;

11:putfield#4;//Fields1:Ljava/lang/String;

14:aload_0

15:ldc#5;//Strings2

17:putfield#6;//Fields2:Ljava/lang/String;

20:ldc#7;//Strings3

22:astore_1

23:aload_0

24:ldc#2;//Strings1

26:putfield#4;//Fields1:Ljava/lang/String;

29:return

publicdebug.Test(java.lang.String);

Code:

0:aload_0

1:invokespecial#1;//Methodjava/lang/Object."":()V

4:aload_0

5:aload_0

6:ldc#2;//Strings1

8:invokevirtual#3;//Methodrt:(Ljava/lang/String;)Ljava/lang/String;

11:putfield#4;//Fields1:Ljava/lang/String;

14:aload_0

15:ldc#5;//Strings2

17:putfield#6;//Fields2:Ljava/lang/String;

20:ldc#7;//Strings3

22:astore_2

23:new#8;//classjava/lang/RuntimeException

26:dup

27:invokespecial#9;//Methodjava/lang/RuntimeException."":()V

30:athrow

java.lang.Stringrt(java.lang.String);

Code:

0:aload_1

1:areturn

publicstaticvoidmain(java.lang.String[]);

Code:

0:new#10;//classdebug/Test

3:dup

4:ldc#11;//String

6:invokespecial#12;//Method"":(Ljava/lang/String;)V

9:pop

10:return

}

相关问答

Q1: java 编程中为何创建变量后需要初始化

java是类型安全语言。java语言的这个设计来自这个想法:

一个变量在没有值之前是不能用它或准确的说不能读其值的，因为没有值，对它进行运算没有意义。因此，做个内置规定

在创建变量在使用前必须初始化，从而帮java程序员避免问题。

Q2: java 初始化

补充java代码初始化的作用：java要求方法级别的变量都要初始化。这是java的特点。用来提高代码的安全性（内存寻址）。

请参考java代码初始化的作用：

--------------------

程序没有编译问题java代码初始化的作用，运行也很正常，运行结果为java代码初始化的作用：

1 2 3 4 8 7 6 5The minimum is 1

java代码初始化的作用的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java代码初始化的作用是什么、java代码初始化的作用的信息别忘了在本站进行查找喔。