关于Java 初始化，有多文章都用了很大篇幅的介绍。经典的<<Thinking in java>>更是用了专门的
一章来介绍Java初始化。但在大量有代码实例后面，感觉上仍然没有真正深入到初始化的本质。
本文以作者对JVM的理解和自己的经验，对Java的初始化做一个比深入的说明，由于作者有水平限制，
以及JDK各实现版本的变化，可能仍然有不少错误和缺点。欢迎行家高手赐教。
要深入了解Java初始化，我们无法知道从程序流程上知道JVM是按什么顺序来执行的。了解JVM的执行
机制和堆栈跟踪是有效的手段。可惜的是，到目前为止。JDK1。4和JDK1。5在javap功能上却仍然存在
着BUG。所以有些过程我无法用实际的结果向你证明两种相反的情况
<<Thinking in java>>(第三版)在第四章一开始的时候,这样来描述Java的初始化工作:
以下译文原文:
可以这样认为,每个类都有一个名为Initialize()的方法,这个名字就暗示了它得在使用之前调用,不幸
的是,这么做的话,用户就得记住要调用这个方法,java类库的设计者们可以通过一种被称为构造函数的
特殊方法,来保证每个对象都能得到被始化.如果类有构造函数,那么java就会在对象刚刚创建,用户还来
不及得到的时候,自动调用那个构造函数,这样初始化就有保障了。
我不知道原作者的描述和译者的理解之间有多大的差异,结合全章,我没有发现两个最关键的字"<clinit>"
和"<init>"。至少说明原作者和译者并没有真正说明JVM在初始化时做了什么,或者说并不了解JVM的初始化
内幕,要不然明明有这两个方法,却为什么要认为有一个事实上并不存在的"Initialize()"方法呢?
"<clinit>"和"<init>"方法在哪里？
这两个方法是实际存在而你又找不到的方法，也许正是这样才使得一些大师都犯晕。加上jdk实现上的一
些BUG，如果没有深入了解，真的让人摸不着北。
现在科学体系有一个奇怪的现象，那么庞大的体系最初都是建立在一个假设的基础是，假设1是正确的，
由此推导出2，再继续推导出10000000000。可惜的是太多的人根本不在乎2-100000000000这样的体系都
是建立在假设1是正确的基础上的。我并不会用“可以这样认为”这样的假设，我要确实证明"<clinit>"
和"<init>"方法是真真实实的存在的：
package debug;
public class MyTest{
static int i = 100/0;
public static void main(String[] args){
Ssytem.out.println("Hello,World!");
}
}
执行一下看看,这是jdk1.5的输出：
java.lang.ExceptionInInitializerError
Caused by: java.lang.ArithmeticException: / by zero
at debug.MyTest.<clinit>(Test.java:3)
Exception in thread "main"
请注意，和其它方法调用时产生的异常一样，异常被定位于debug.MyTest的<clinit>.
再来看：
package debug;
public class Test {
Test(){
int i = 100 / 0;
}
public static void main(String[] args) {
new Test();
}
}
jdk1.5输入：
Exception in thread "main" java.lang.ArithmeticException: / by zero
at debug.Test.<init>(Test.java:4)
at debug.Test.main(Test.java:7)
JVM并没有把异常定位在Test()构造方法中，而是在debug.Test.<init>。
当我们看到了这两个方法以后，我们再来详细讨论这两个“内置初始化方法”（我并不喜欢生造一些
非标准的术语，但我确实不知道如何规范地称呼他们）。
内置初始化方法是JVM在内部专门用于初始化的特有方法，而不是提供给程序员调用的方法，事实上
“<>”这样的语法在源程序中你连编译都无法通过。这就说明，初始化是由JVM控制而不是让程序员
来控制的。
类初始化方法：<clinit>
我没有从任何地方了解到<clinit>的cl是不是class的简写，但这个方法确实是用来对“类”进行初
始化的。换句话说它是用来初始化static上下文的。
在类装载（load）时，JVM会调用内置的<clinit>方法对类成员和静态初始化块进行初始化调用。它们
的顺序按照源文件的原文顺序。
我们稍微增加两行static语句：
package debug;
public class Test {
static int x = 0;
static String s = "123";
static {
String s1 = "456";
if(1==1)
throw new RuntimeException();
}
public static void main(String[] args) {
new Test();
}
}
然后进行反编译：
javap -c debug.Test
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
static int x;
static java.lang.String s;
public debug.Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: new #2; //class debug/Test
3: dup
4: invokespecial #3; //Method "<init>":()V
7: pop
8: return
static {};
Code:
0: iconst_0
1: putstatic #4; //Field x:I
4: ldc #5; //String 123
6: putstatic #6; //Field s:Ljava/lang/String;
9: ldc #7; //String 456
11: astore_0
12: new #8; //class java/lang/RuntimeException
15: dup
16: invokespecial #9; //Method java/lang/RuntimeException."<init>":()V
19: athrow
}
我们可以看到,类初始化正是按照源文件中定义的原文顺序进行。先是声明
static int x;
static java.lang.String s;
然后对int x和String s进行赋值：
0: iconst_0
1: putstatic #4; //Field x:I
4: ldc #5; //String 123
6: putstatic #6; //Field s:Ljava/lang/String;
执行初始化块的String s1 = "456";生成一个RuntimeException抛
9: ldc #7; //String 456
11: astore_0
12: new #8; //class java/lang/RuntimeException
15: dup
16: invokespecial #9; //Method java/lang/RuntimeException."<init>":()V
19: athrow
要明白的是，"<clinit>"方法不仅是类初始化方法，而且也是接口初始化方法。并不是所以接口
的属性都是内联的，只有直接赋常量值的接口常量才会内联。而
[public static final] double d = Math.random()*100;
这样的表达式是需要计算的，在接口中就要由"<clinit>"方法来初始化。
下面我们再来看看实例初始化方法"<init>"
"<init>"用于对象创建时对对象进行初始化，当在HEAP中创建对象时，一旦在HEAP分配了空间。最
先就会调用"<init>"方法。这个方法包括实例变量的赋值（声明不在其中）和初始化块，以及构造
方法调用。如果有多个重载的构造方法，每个构造方法都会有一个对应的"<init>"方法。构造方法
隐式或显示调用父类的构造方法前,总是先执行实例变量初始化和初始化块.同样，实例变量和初始
化块的顺序也是按源文件的原文顺序执行，构造方法中的代码在最后执行：
package debug;
public class Test {
int x = 0;
String s = "123";
{
String s1 = "456";
//if(1==1)
//throw new RuntimeException();
}
public Test(){
String ss = "789";
}
public static void main(String[] args) {
new Test();
}
}
javap -c debug.Test的结果：
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
int x;
java.lang.String s;
public debug.Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: aload_0
5: iconst_0
6: putfield #2; //Field x:I
9: aload_0
10: ldc #3; //String 123
12: putfield #4; //Field s:Ljava/lang/String;
15: ldc #5; //String 456
17: astore_1
18: ldc #6; //String 789
20: astore_1
21: return
public static void main(java.lang.String[]);
Code:
0: new #7; //class debug/Test
3: dup
4: invokespecial #8; //Method "<init>":()V
7: pop
8: return
}
如果在同一个类中，一个构造方法调用了另一个构造方法，那么对应的"<init>"方法就会调用另一
个"<init>"，但是实例变量和初始化块会被忽略，否则它们就会被多次执行。
package debug;
public class Test {
String s1 = rt("s1");
String s2 = "s2";
public Test(){
s1 = "s1";
}
public Test(String s){
this();
if(1==1) throw new Runtime();
}
String rt(String s){
return s;
}
public static void main(String[] args) {
new Test("");
}
}
反编译的结果：
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
java.lang.String s1;
java.lang.String s2;
public debug.Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: aload_0
5: aload_0
6: ldc #2; //String s1
8: invokevirtual #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
11: putfield #4; //Field s1:Ljava/lang/String;
14: aload_0
15: ldc #5; //String s2
17: putfield #6; //Field s2:Ljava/lang/String;
20: aload_0
21: ldc #2; //String s1
23: putfield #4; //Field s1:Ljava/lang/String;
26: return
public debug.Test(java.lang.String);
Code:
0: aload_0
1: invokespecial #7; //Method "<init>":()V
4: new #8; //class java/lang/RuntimeException
7: dup
8: invokespecial #9; //Method java/lang/RuntimeException."<init>":()V
11: athrow
java.lang.String rt(java.lang.String);
Code:
0: aload_1
1: areturn
public static void main(java.lang.String[]);
Code:
0: new #10; //class debug/Test
3: dup
4: ldc #11; //String
6: invokespecial #12; //Method "<init>":(Ljava/lang/String;)V
9: pop
10: return
}
我们看到，由于Test(String s)调用了Test();所以"<init>":(Ljava/lang/String;)V不再对
实例变量和初始化块进次初始化：
public debug.Test(java.lang.String);
Code:
0: aload_0
1: invokespecial #7; //Method "<init>":()V
4: new #8; //class java/lang/RuntimeException
7: dup
8: invokespecial #9; //Method java/lang/RuntimeException."<init>":()V
11: athrow
而如果两个构造方法是相互独立的，则每个构造方法调用前都会执行实例变量和初始化块的调用：
package debug;
public class Test {
String s1 = rt("s1");
String s2 = "s2";
{
String s3 = "s3";
}
public Test() {
s1 = "s1";
}
public Test(String s) {
if (1 == 1)
throw new RuntimeException();
}
String rt(String s) {
return s;
}
public static void main(String[] args) {
new Test("");
}
}
反编译的结果：
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
java.lang.String s1;
java.lang.String s2;
public debug.Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: aload_0
5: aload_0
6: ldc #2; //String s1
8: invokevirtual #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
11: putfield #4; //Field s1:Ljava/lang/String;
14: aload_0
15: ldc #5; //String s2
17: putfield #6; //Field s2:Ljava/lang/String;
20: ldc #7; //String s3
22: astore_1
23: aload_0
24: ldc #2; //String s1
26: putfield #4; //Field s1:Ljava/lang/String;
29: return
public debug.Test(java.lang.String);
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: aload_0
5: aload_0
6: ldc #2; //String s1
8: invokevirtual #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
11: putfield #4; //Field s1:Ljava/lang/String;
14: aload_0
15: ldc #5; //String s2
17: putfield #6; //Field s2:Ljava/lang/String;
20: ldc #7; //String s3
22: astore_2
23: new #8; //class java/lang/RuntimeException
26: dup
27: invokespecial #9; //Method java/lang/RuntimeException."<init>":()V
30: athrow
java.lang.String rt(java.lang.String);
Code:
0: aload_1
1: areturn
public static void main(java.lang.String[]);
Code:
0: new #10; //class debug/Test
3: dup
4: ldc #11; //String
6: invokespecial #12; //Method "<init>":(Ljava/lang/String;)V
9: pop
10: return
}
明白了上面这些知识,我们来做一个小测试吧:
public class Test2 extends Test1{
{
System.out.print("1");
}
Test2(){
System.out.print("2");
}
static{
System.out.print("3");
}
{
System.out.print("4");
}
public static void main(String[] args) {
new Test2();
}
}
class Test1 {
Test1(){
System.out.print("5");
}
static{
System.out.print("6");
}
}
试试看能清楚打印的顺序吗?如果没有new Test2()将打印什么?
分享到：
相关推荐
`<clinit>`和`<init>`方法的存在揭示了Java初始化的底层机制，它们确保了类和对象的正确初始化，同时也提供了异常处理的能力，使得在初始化过程中出现的问题能够被准确捕获和定位。 总结： Java初始化涉及类的静态...
总结来说，Java初始化与方法是编程基础，深入理解这两个概念对于任何Java开发者都至关重要。通过阅读源码、运用开发工具和不断实践，我们可以不断提高自己的编程水平，从而在实际工作中游刃有余。
让我们深入探讨Java中的初始化顺序及其背后的机制。 1. **类加载阶段**： 在Java程序运行时，JVM会先加载类的字节码文件（.class文件）。这个过程包括加载、验证、准备、解析和初始化五个步骤。这里我们主要关注...
在Java编程语言中，初始化块是程序执行时用于初始化对象或类的重要机制。这里我们将深入探讨两种类型的初始化块：静态初始化块（Static Initializer Block）和对象初始化块（Instance Initializer Block）。这两种...
### 深入Java虚拟机加载初始化 #### Classloader的作用及意义 在深入了解Java虚拟机（JVM）的加载初始化之前，我们先明确一下`Classloader`的角色。简单地说，`Classloader`的主要职责是将编译后的`.class`文件...
【深入Java虚拟机（三）——类的生命周期(下）类的初始化1】 类的生命周期在Java中是一个关键的概念，它涵盖了从加载到卸载的整个过程。在类的生命周期中，初始化阶段是非常重要的，因为它涉及到类的静态变量的赋值...
"Java初级视频教程系列之-java初始化"是一套专为初学者设计的教育内容，由经验丰富的IT专家精心录制，旨在帮助学习者掌握Java编程的基础，特别是关于对象初始化的重要概念。 在Java中，初始化是一个关键的步骤，它...
本篇文章将深入探讨C++和Java中变量和成员初始化的差异，并通过具体的代码示例进行对比。 在C++中，初始化顺序遵循以下规则： 1. 静态成员变量：无论它们在哪里定义，静态成员变量都按照声明的顺序初始化。 2. 非...
本文将深入探讨Java中的初始化过程，包括对象的构造器初始化以及类成员的初始化顺序，同时也会涉及Java的垃圾回收机制，即内存的自动清理。 首先，让我们详细了解一下Java中的构造器初始化。构造器是Java中用于初始...
### Java中对象创建、初始化与引用详解 #### 一、Java对象、引用及创建过程 在Java中，对象是程序的基本单位，它包含了属性（成员变量）和行为（方法）。对象是由类创建出来的实例，而类则是一组具有相同属性和...
总结起来，Java初始化开发环境涉及到创建合理的目录结构，设置项目分层，初始化Node.js服务框架Koa2，以及连接NoSQL数据库MongoDB并使用Mongoose进行数据操作。这些步骤确保了项目从一开始就具备良好的可扩展性和可...
理解ClassLoader的工作机制以及类变量初始化的顺序对于深入理解Java运行时环境至关重要。这篇博文将探讨这两个主题。 首先，让我们深入了解Java的ClassLoader。ClassLoader是一个抽象类，它是Java中的一个关键组件...
Java代码的初始化流程是编程者在开发过程中需要深入了解的关键环节，它涉及到类加载、静态变量初始化、构造函数执行等多个步骤。下面将详细讲解这个过程。 首先，Java代码的执行始于类加载。当程序运行时，Java...
《深入解析 ORACLE 数据库的初始化》是由知名数据库专家盖国强编著的一本专业书籍，专注于探讨 Oracle 数据库在启动、配置和管理过程中的各项技术细节。这本书以丰富的实例和深入的理论相结合，旨在帮助读者全面理解...
### Java学习之神奇初始化 #### 知识点详解 在Java编程语言中，类的初始化顺序是一个非常重要的概念。特别是当涉及到静态成员（`static`）的初始化时，这一顺序对于理解程序的行为至关重要。根据提供的文件信息，...
在DEMO中，`multDb-init.sql`可能包含了初始化多个数据库的数据脚本，用于设置各个数据源的基础数据环境。这些脚本通常包含了创建表、插入初始数据等操作，以便于测试和演示。 `说明.txt`文件很可能是对DEMO的详细...
这篇博客“Vector初始化的各种写法”可能探讨了如何在程序开始时设置和填充一个Vector对象的不同方法。虽然没有提供具体的博客内容，但我们可以根据标题推测并详细阐述一些常见的Vector初始化技术。 1. **默认初始...
在Java中，对象初始化的过程分为几个步骤，包括默认初始化、显式初始化和构造器初始化。 **默认初始化**是指Java为所有基本类型的变量提供默认值。如在示例代码中所示，布尔类型`boolean`的默认值是`false`，字符...
类加载机制是JVM的重要特性，它包括加载、验证、准备、解析和初始化五个阶段。这个过程确保了类的安全性和正确性。双亲委派模型是类加载机制的一种实现，它避免了类的重复加载，并保证了类加载的有序性。 垃圾收集...