java构造器特性,从JVM看Java语言特性(二) 构造器解析

1. 构造器解析

只要学过Java的人都知道, JVM在创建一个对象的时候会通过构造函数来决定这个类要如何构造, 构造函数在Java中是非常特殊的一类"方法", 通过这篇文章我们来探索一下构造器的底层实现.

还是以Tree.java为例, 分析一下Tree的字节码

public class Tree {

public static int state = 1;

int height;

public Tree(){

height = 0;

}

public Tree(int initialHeight){

height = initialHeight;

}

public static void message(String message){

return;

}

}

我定义了一个静态字段外加一个静态方法, 之后可以顺带分析一下带static标识的字段和方法是如何构造的. 现在先来看Tree的两个构造器:

public Dao.Tree();

descriptor: ()V

flags: (0x0001) ACC_PUBLIC

Code:

stack=2, locals=1, args_size=1

0: aload_0

1: invokespecial #1 // Method java/lang/Object."":()V

4: aload_0

5: iconst_0

6: putfield #2 // Field height:I

9: return

LineNumberTable:

line 8: 0

line 9: 4

line 10: 9

public Dao.Tree(int);

descriptor: (I)V

flags: (0x0001) ACC_PUBLIC

Code:

stack=2, locals=2, args_size=2

0: aload_0

1: invokespecial #1 // Method java/lang/Object."":()V

4: aload_0

5: iload_1

6: putfield #2 // Field height:I

9: return

LineNumberTable:

line 12: 0

line 13: 4

line 14: 9

从字节码中我们看出, 无论是怎么样的构造器, 在一开始都会调用, 在之后才是构造器自己的逻辑. 事实上, 对于一个类的任何构造器, 编译器都会修改构造函数的字节码指令, 将Java类成员变量的初始化指令插入到构造方法中, 那么这个是什么呢? <>的作者认为就是无参构造器, 简直就是在胡说八道, 我们不妨试一下把无参构造去掉看看会是是怎么样的情况:

public class Tree {

public static int state = 1;

int height;

public Tree(int initialHeight){

height = initialHeight;

}

public static void message(String message){

return;

}

}

构造器的字节码为:

public Dao.Tree(int);

descriptor: (I)V

flags: (0x0001) ACC_PUBLIC

Code:

stack=2, locals=2, args_size=2

0: aload_0

1: invokespecial #1 // Method java/lang/Object."":()V

4: aload_0

5: iload_1

6: putfield #2 // Field height:I

9: return

LineNumberTable:

line 8: 0

line 9: 4

line 10: 9

非常明显的, 这个类里面没有无参构造器, 但是却有, 这个结果非常轻易的就打了脸. 这样看来和无参构造器没有什么关系, 那么里面到底干了点啥呢? 实际上, 在中, JVM主要完成Java类成员变量的初始化逻辑, 同时会执行Java类中被{}包裹的块逻辑. 如果成员变量没有被赋值, 那么不会被初始化, 也就不会放在里面.

我们不妨举个例子, 对于下面这个类:

public class Tree {

int height = 3;

public Tree(){

}

public Tree(String message){

System.out.println(message);

}

}

它在JVM里面的表示应该就是:

public class Tree {

int height;

public Tree(){

height = 3;

}

public Tree(String message){

height = 3;

System.out.println(message);

}

}

这样就非常清楚了, 的作用就是把写在构造器外的字段赋值和{}块写到构造器里面, 让所有构造器有了共同的一段初始化, 减少了代码的重复性.

这里插几句, 关于构造器到底是个什么东西, <>中认为构造器是一个静态方法的, 这个观点是非常有问题的. 首先, 在调用构造器的时候会将this引用传入, 字节码中对应的就是aload_0, 而静态方法因为是全局的, 是不可能传入this的, 这一点决定了他不可能是一个静态方法. 那么它有没有可能是一个私有的方法呢? 也不可能, 非常明显一点的是构造器本身是跟着这个类走的, 就连它是不是方法都不好说, 因为除了再new一个对象的时候会调用这个构造器, 其他时候是没有使用的(更正: 反射可以将构造器反射出来, 并且通过newInstance调用). 从这一点说的话构造器可以说是一种非常特殊的"方法".

2. 静态初始化解析

一旦理解了的含义, 就会显得很简单, 因为它们俩的作用基本差不多, 只不过一个是普通成员的初始化, 一个静态初始化. 本文开头的Tree.java的静态相关的的字节码如下

public static void message(java.lang.String);

descriptor: (Ljava/lang/String;)V

flags: (0x0009) ACC_PUBLIC, ACC_STATIC

Code:

stack=0, locals=1, args_size=1

0: return

LineNumberTable:

line 17: 0

static {};

descriptor: ()V

flags: (0x0008) ACC_STATIC

Code:

stack=1, locals=0, args_size=0

0: iconst_1

1: putstatic #3 // Field state:I

4: return

LineNumberTable:

line 5: 0

这里的static {}就是方法, 作用是完成了静态字段的赋值, 和执行static代码段. 我们列一张表来对比一下和的区别:

初始化内容

普通成员变量赋值以及{}代码块

静态变量赋值以及static {}代码块

调用时机

对象构建时

类加载时(初始化)

继承

可以继承

不能继承

可以看出, 不仅加载时间比早很多, 并且在类加载时就会被调用. 关于的调用时机, 一个最明显的例子就是注册JDBC Driver的时候只需要加一句

Class.forName("com.mysql.jdbc.Driver");

Driver就自己加载了, 这是为什么呢? 其实非常简单, com.mysql.jdbc.Driver这个类一共就一个构造方法再加一个下面的静态代码段, 在forName的时候这段代码就自动被加载进JVM, 完成了driver的注册:

static {

try {

DriverManager.registerDriver(new Driver());

} catch (SQLException var1) {

throw new RuntimeException("Can't register driver!");

}

}

挺有意思的吧?

3. 构造器的继承解析

在构造器的继承中, 和这两者到底扮演着什么样的角色是我们所关心的, 简单来说不具有继承性, 原因很简单, 父类和子类是分别加载的, 在父类加载时就已经执行过方法, 就无需在子类再加载一遍, 所以子类只需要完成自己的就行.

而对于来说情况就比较复杂, 当Java类显示继承父类时, 则Java编译器会让子类的各个构造函数调用父类的默认构造函数(). 从而在子类实例化是完成父类成员变量的初始化逻辑.

举个例子, 帮助你彻底理清新建对象时候的初始化问题:

public class Father {

{

System.out.println("father.{}");

}

static {

System.out.println("father.static{}");

}

public Father(){

System.out.println("father.constructor()");

}

}

public class Son extends Father{

{

System.out.println("Son.{}");

}

static {

System.out.println("Son.static{}");

}

public Son(){

System.out.println("Son.constructor");

}

public static void main(String[] args) {

Son son = new Son();

}

}

执行结果为:

father.static{}

Son.static{}

father.{}

father.constructor()

Son.{}

Son.constructor

从这个结果来看, 当新建一个对象时, 总是先加载父类再加载子类, 并且执行了他们的静态初始化过程, 也就是, 接着再执行父类的默认无参构造函数(注意, 这里只能是无参构造器, 若父类没有无参构造器, 那么编译器会报错), 最后才是子类的构造函数.

从这个结果中我们还能看出, {}代码段是在构造器的输出之前执行的, 也间接证明了被插入在了构造器的最前面.