深入分析java中类的构造

概要：本文通过查看一个精心构造的类结构的运行输出和使用javap工具查看实际生成的java字节码（bytecode）向java程序员展示了一个类在运行时是如何构造生成的。

　　关键字： java 构造 javap 字节码 bytecode

　　按照java规范，一个类实例的构造过程是遵循以下顺序的：

　　1.如果构造方法（constructor，也有翻译为构造器和构造函数的）是有参数的则进行参数绑定。

　　2.内存分配将非静态成员赋予初始值（原始类型的成员的值为规定值，例如int型为0，float型为0.0f，boolean型为false；对象类型的初始值为null），静态成员是属于类对象而非类实例，所以类实例的生成不进行静态成员的构造或者初始化，后面将讲述静态成员的生成时间。

　　3.如果构造方法中存在this()调用（可以是其它带参数的this()调用）则执行之，执行完毕后进入第6步继续执行，如果没有this调用则进行下一步。

　　4.执行显式的super()调用（可以是其它带参数的super()调用）或者隐式的super()调用（缺省构造方法），此步骤又进入一个父类的构造过程并一直上推至Object对象的构造。

　　5.执行类申明中的成员赋值和初始化块。

　　6.执行构造方法中的其它语句。

　　现在来看看精心构造的一个实例：


　　class Parent
　　{
　　int pm1;
　　int pm2=10;
　　int pm3=pmethod();
　　{
　　System.out.println("Parent@#s instance initialize block");
　　}
　　public static int spm1=10;
　　static
　　{
　　System.out.println("Parent@#s static initialize block");
　　}
　　
　　Parent()
　　{
　　System.out.println("Parent@#s default constructor");
　　}
　　static void staticmethod()
　　{
　　System.out.println("Parent@#s staticmethod");
　　}


　int pmethod()
　　{
　　System.out.println("Parent@#s method");
　　return 3;
　　}
　　}

　　class Child extends Parent
　　{
　　int cm1;
　　int cm2=10;
　　int cm3=cmethod();
　　Other co;
　　public static int scm1=10;
　　{
　　System.out.println("Child@#s instance initialize block");
　　}
　　static
　　{
　　System.out.println("Child@#s static initialize block");
　　}
　　
　　Child()
　　{
　　co=new Other();
　　System.out.println("Child@#s default constructor");
　　}
　　Child(int m)
　　{
　　this();
　　cm1=m;
　　System.out.println("Child@#s self-define constructor");
　　}
　　static void staticmethod()
　　{
　　System.out.println("Child@#s staticmethod");
　　}
　　
　　int cmethod()
　　{
　　System.out.println("Child@#s method");
　　return 3;
　　}

　　}

　　class Other
　　{
　　int om1;
　　Other() {
　　System.out.println("Other@#s default constructor");
　　}

　　}
　public class InitializationTest
　　{
　　public static void main(String args[])
　　{
　　Child c;
　　System.out.println("program start");
　　System.out.println(Child.scm1);
　　c= new Child(10);
　　System.out.println("program end");
　　}
　　}





　　进入此文件所在的目录，然后
　　编译此文件：javac InitializationTest.java
　　运行此程序：java ?classpath . InitializationTest
　　得到的结果是：


　　program start
　　Parent@#s static initialize block
　　Child@#s static initialize block
　　10
　　Parent@#s method
　　Parent@#s instance initialize block
　　Parent@#s default constructor
　　Child@#s method
　　Child@#s instance initialize block
　　Other@#s default constructor
　　Child@#s default constructor
　　Child@#s self-define constructor
　　program end




　　如果没有看过上面的关于类的构造的说明，很容易让人误解为类的构造顺序是如下的结果（忽略参数绑定、内存分配和非静态成员的缺省值赋值）：

　　1.完成父类的非静态成员初始化赋值以及执行初始化块（这个的先后顺序取决于源文件中的书写顺序，可以将初始化块置于成员声明前，那么先执行的将是初始化块，将上面的代码稍稍变动一下就可以验证这一点。）

　　2.调用父类的构造方法完成父类构造。

　　3.完成非静态成员的初始化赋值以及执行初始化块。

　　4.调用构造方法完成对象的构造，执行构造方法体中的其它内容。

　　如果根据以上java规范中给出的顺序也可以合理的解释程序的输出结果，那么如何亲眼看到是规范中的顺序而不是以上根据程序的输出推断的顺序呢？
　　下面就使用JDK自带的javap工具看看实际的顺序，这个工具是一个根据编译后的字节码生成一份字节码的助记符格式的文档的工具，就像根据机器码生成汇编代码那样。


反编译：javap -c -classpath . Child
　　输出的结果是（已经经过标记，交替使用黑体和斜体表示要讲解的每一块）：


　　Compiled from InitializationTest.java
　　class Child extends Parent {
　　int cm1;
　　int cm2;
　　int cm3;
　　Other co;
　　public static int scm1;
　　static {};
　　Child();
　　Child(int);
　　int cmethod();
　　static void staticmethod();
　　}

　　Method static {}
　　0 bipush 10
　　2 putstatic #22 <Field int scm1>
　　5 getstatic #20 <Field java.io.PrintStream out>
　　8 ldc #5 <String "Child@#s static initialize block">
　　10 invokevirtual #21 <Method void println(java.lang.String)>
　　13 return

　　Method Child()
　　0 aload_0
　　1 invokespecial #14 <Method Parent()>
　　4 aload_0
　　5 bipush 10
　　7 putfield #16 <Field int cm2>
　　10 aload_0
　　11 aload_0
　　12 invokevirtual #18 <Method int cmethod()>
　　15 putfield #17 <Field int cm3>
　　18 getstatic #20 <Field java.io.PrintStream out>
　　21 ldc #2 <String "Child@#s instance initialize block">
　　23 invokevirtual #21 <Method void println(java.lang.String)>
　　26 aload_0
　　27 new #8 <Class Other>
　　30 dup
　　31 invokespecial #13 <Method Other()>
　　34 putfield #19 <Field Other co>
　　37 getstatic #20 <Field java.io.PrintStream out>
　　40 ldc #1 <String "Child@#s default constructor">
　　42 invokevirtual #21 <Method void println(java.lang.String)>
　　45 return

　　Method Child(int)
　　0 aload_0
　　1 invokespecial #12 <Method Child()>
　　4 aload_0
　　5 iload_1


6 putfield #15 <Field int cm1>
　　9 getstatic #20 <Field java.io.PrintStream out>
　　12 ldc #4 <String "Child@#s self-define constructor">
　　14 invokevirtual #21 <Method void println(java.lang.String)>
　　17 return

　　Method int cmethod()
　　0 getstatic #20 <Field java.io.PrintStream out>
　　3 ldc #3 <String "Child@#s method">
　　5 invokevirtual #21 <Method void println(java.lang.String)>
　　8 iconst_3
　　9 ireturn

　　Method void staticmethod()
　　0 getstatic #20 <Field java.io.PrintStream out>
　　3 ldc #6 <String "Child@#s staticmethod">
　　5 invokevirtual #21 <Method void println(java.lang.String)>
　　8 return





　　请仔细浏览一下这个输出并和源代码比较一下。

　　下面解释如何根据这个输出得到类实例的实际的构造顺序，在开始说明前先解释一下输出的语句的格式，语句中最前面的一个数字是指令的偏移值，这个我们在此可以不管，第二项是指令助记符，可以从字面上大致看出指令的意思。

　　例如 getstatic 指令将一个静态成员压入一个称为操作数堆栈（后续的指令就可以引用这个数据结构中的成员）的数据结构，而 invokevirtual 指令是调用java虚拟机方法，第三项是操作数（#号后面跟一个数字，实际上是类的成员的标记），有些指令没有这一项，因为有些指令如同汇编指令中的某些指令一样是不需要操作数的（可能是操作数是隐含的或者根本就不需要），这是java中的一个特色。

　　如果你直接检查字节码，你会看到成员信息没有直接嵌入指令而是像所有由java类使用的常量那样存储在一个共享池中，将成员信息存储在一个常量池中可以减小字节码指令的大小，因为指令只需要存储常量池中的一个索引而不是整个常量。

　　需要说明的是常量池中的项目的顺序是和编译器相关的，因此在你的环境中看到的可能和我上面给出的输出不完全一样，第四项是对前面的操作数的说明，实际的字节码中也是没有的，根据这个你能很清楚的得到实际上使用的是哪个成员或者调用的是哪个方法，这也是javap为我们提供的便利。

　　说完上面这些你现在应该很容易看懂上面的结果和下面将要叙述的内容了。其它更进一步的有关java字节码的信息请自己查找资料。

　　先看看最开始的部分，很像一个标准的c++类的声明，确实如此。成员声明的后面没有了成员初始化赋值语句和初始化块，那么这些语句何时执行的呢？先不要急，继续往下看。

　　第二块，是一个Method static {}，对比看看第一部分，它被处理为一个静态的方法（从前面的Method可以看出），这就是源代码中的静态初始化块，从后面的语句可以看出它执行的就是System.out.println("Child@#s static initialize block")语句，由于这个方法是没有方法名的，所以它不能被显式的调用，它在何处调用后面会有叙述。
第三块，缺省构造方法的实现，这是本文的重点，下面详细讲解。由于源代码中的缺省构造方法没有显式调用this方法，因此没有this调用（对比看看下一块的有参的构造方法的前两句），同时也没有显式的super调用，那么隐式调用父类的缺省构造方法，也就是前两条语句（主要是语句invokespecial #14 <Method Parent()>），它调用父类的构造方法，和这个类的构造相似（你可以使用javap ?c ?classpath . Parent反编译父类的字节码看看这个类的构造过程）；紧接着的是执行源代码中的第一条初始化赋值语句cm2=10（即接下来的三条语句，主要是bipush 10和putfield #15 <Field int cm2>，此处回答了第一块中的疑问，即初始化赋值语句到哪儿去了。）；接下来是执行cm3=cmethod()（接下来的四条语句）；然后是执行初始化块中的内容System.out.println("Child@#s instance initialize block")（接下来的三条语句）；java规范内部约定的内容至此执行完毕，开始执行构造方法的方法体中的内容，即co=new Other()（接下来的五条语句）和System.out.println("Child@#s default constructor")（接下来的三条语句），最后方法执行完毕返回（最后一条语句return）。

　　剩下的几块相信应该不用解释了吧，有参构造方法调用无参构造方法然后执行自己的方法体，成员方法cmethod执行一条打印语句然后返回一个常量3，静态方法staticmethod执行一条打印语句。

　　另外需要说明一下的是你可以将有参构造方法中的this调用去掉，然后看看反编译的结果，你会发现两个构造方法非常的类似，如果你将两个构造方法的内容改为一样的，那么反编译后的生成也将是同样的。从这个可以说明本文开始的构造顺序的说明中构造方法中this调用的判断是在编译阶段就完成的，而不是在运行阶段（说明中的意思好像是这个判断是在运行时进行的）。

　　对构造过程的另一个细节你可能还不相信，就是顺序中的第二条关于非静态成员的赋予缺省初始值（内存分配部分无法考证，这是java虚拟机自动完成的），这个你可以通过在子类Child的cmethod方法的最开始用 System.out.println(cm3)打印cm3的值（输出为0，其它类型成员的值可以通过类似的方法得到）。

　　下面来讲解另一个还没有解决的问题：静态成员初始化和静态初始化块的执行是在何时完成的？这个可以通过一个小小的试验推断得到：是在第一次使用该类对象时进行的（注意是类对象而不是类实例，对于类的公有静态成员可以直接通过类名进行访问，并不需要生成一个类实例，这就是一次类对象的使用而非类实例的使用，如果在生成第一个类实例前没有使用过该类对象，那么在构造第一个类实例前先完成类对象的构造（即完成静态成员初始化以及执行静态初始化块），然后再执行以上类实例的构造过程），试验的步骤如下：

　　1.修改main方法，将其中的System.out.println(Child.scm1)和c= new Child(10)都注释掉（不要删除，后面还需要用到这两个语句），编译运行程序，输出将只有program start和program end，这说明没有使用类对象也没有生成类实例时不进行静态成员的构造。

　　2.将System.out.println(Child.scm1)的注释取消，编译运行后输出多了父类和子类的静态初始化块部分的执行输出（使用子类的类对象将导致生成父类的类对象，父类先于子类构造）。

　　3.将System.out.println(Child.scm1)注释掉并取消c= new Child(10)的注释，编译运行后输出只比最开始没有注释任何语句时少了一条（输出Child.scm1的值10）

　　从以上的试验中我们可以得到前面的结论。
　　本文至此可以说结束了，由于本人的java功底并不很扎实，java规范看得也不完整，因此文中可能有错误，如果您觉得某些地方有错误的话，欢迎通过mail联系。

原文转自：http://www.ltesting.net