在Java中，一个对象在可以被使用之前必须要被正确地初始化，这一点是Java规范规定的。本文试图对Java如何执行对象的初始化做一个详细深入地介绍(与对象初始化相同，类在被加载之后也是需要初始化的，本文在最后也会对类的初始化进行介绍，相对于对象初始化来说，类的初始化要相对简单一些)。

1.Java对象何时被初始化

Java对象在其被创建时初始化，在Java代码中，有两种行为可以引起对象的创建。其中比较直观的一种，也就是通常所说的显式对象创建，就是通过new关键字来调用一个类的构造函数，通过构造函数来创建一个对象，这种方式在java规范中被称为“由执行类实例创建表达式而引起的对象创建”。
当然，除了显式地创建对象，以下的几种行为也会引起对象的创建，但是并不是通过new关键字来完成的，因此被称作隐式对象创建，他们分别是：

● 加载一个包含String字面量的类或者接口会引起一个新的String对象被创建，除非包含相同字面量的String对象已经存在与虚拟机内了(JVM会在内存中会为所有碰到String字面量维护一份列表，程序中使用的相同字面量都会指向同一个String对象)，比如，

Java
1
2
3
4

class StringLiteral {
private String str = "literal";
private static String sstr = "s_literal";
}

● 自动装箱机制可能会引起一个原子类型的包装类对象被创建，比如，

Java
1
2
3

class PrimitiveWrapper {
private Integer iWrapper = 1;
}

● String连接符也可能会引起新的String或者StringBuilder对象被创建，同时还可能引起原子类型的包装对象被创建，比如(本人试了下，在mac ox下1.6.0_29版本的javac，对待下面的代码会通过StringBuilder来完成字符串的连接，并没有将i包装成Integer，因为StringBuilder的append方法有一个重载，其方法参数是int)，

Java
1
2
3
4
5
6
7

public class StringConcatenation {
private static int i = 1;
public static void main(String... args) {
System.out.println("literal" + i);
}
}

2.Java如何初始化对象

当一个对象被创建之后，虚拟机会为其分配内存，主要用来存放对象的实例变量及其从超类继承过来的实例变量(即使这些从超类继承过来的实例变量有可能被隐藏也会被分配空间)。在为这些实例变量分配内存的同时，这些实例变量也会被赋予默认值。

引用

关于实例变量隐藏

Java
1
2
3
4
5
6
7
8
9
10
11

class Foo {
int i = 0;
}
class Bar extends Foo {
int i = 1;
public static void main(String... args) {
Foo foo = new Bar();
System.out.println(foo.i);
}
}

上面的代码中，Foo和Bar中都定义了变量i，在main方法中，我们用Foo引用一个Bar对象，如果实例变量与方法一样，允许被覆盖，那么打印的结果应该是1，但是实际的结果确是0。
但是如果我们在Bar的方法中直接使用i，那么用的会是Bar对象自己定义的实例变量i，这就是隐藏，Bar对象中的i把Foo对象中的i给隐藏了，这条规则对于静态变量同样适用。

在内存分配完成之后，java的虚拟机就会开始对新创建的对象执行初始化操作，因为java规范要求在一个对象的引用可见之前需要对其进行初始化。在Java中，三种执行对象初始化的结构，分别是实例初始化器、实例变量初始化器以及构造函数。

2.1. Java的构造函数

每一个Java中的对象都至少会有一个构造函数，如果我们没有显式定义构造函数，那么Java编译器会为我们自动生成一个构造函数。构造函数与类中定义的其他方法基本一样，除了构造函数没有返回值，名字与类名一样之外。在生成的字节码中，这些构造函数会被命名成<init>方法，参数列表与Java语言书写的构造函数的参数列表相同(<init>这样的方法名在Java语言中是非法的，但是对于JVM来说，是合法的)。另外，构造函数也可以被重载。

Java要求一个对象被初始化之前，其超类也必须被初始化，这一点是在构造函数中保证的。Java强制要求Object对象(Object是Java的顶层对象，没有超类)之外的所有对象构造函数的第一条语句必须是超类构造函数的调用语句或者是类中定义的其他的构造函数，如果我们即没有调用其他的构造函数，也没有显式调用超类的构造函数，那么编译器会为我们自动生成一个对超类构造函数的调用指令，比如，

1
2
3

public class ConstructorExample {
}

对于上面代码中定义的类，如果观察编译之后的字节码，我们会发现编译器为我们生成一个构造函数，如下，

Java
1
2
3

   aload_0
   invokespecial #8; //Method java/lang/Object."<init>":()V
   return

上面代码的第二行就是调用Object对象的默认构造函数的指令。

正因为如此，如果我们显式调用超类的构造函数，那么调用指令必须放在构造函数所有代码的最前面，是构造函数的第一条指令。这么做才可以保证一个对象在初始化之前其所有的超类都被初始化完成。

如果我们在一个构造函数中调用另外一个构造函数，如下所示，

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class ConstructorExample {
private int i;
ConstructorExample() {
this(1);
....
}
ConstructorExample(int i) {
....
this.i = i;
....
}
}

对于这种情况，Java只允许在ConstructorExample(int i)内出现调用超类的构造函数，也就是说，下面的代码编译是无法通过的，

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class ConstructorExample {
private int i;
ConstructorExample() {
super();
this(1);
....
}
ConstructorExample(int i) {
....
this.i = i;
....
}
}

或者，

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class ConstructorExample {
private int i;
ConstructorExample() {
this(1);
super();
....
}
ConstructorExample(int i) {
....
this.i = i;
....
}
}

Java对构造函数作出这种限制，目的是为了要保证一个类中的实例变量在被使用之前已经被正确地初始化，不会导致程序执行过程中的错误。但是，与C或者C++不同，Java执行构造函数的过程与执行其他方法并没有什么区别，因此，如果我们不小心，有可能会导致在对象的构建过程中使用了没有被正确初始化的实例变量，如下所示，

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class Foo {
int i;
Foo() {
i = 1;
int x = getValue();
System.out.println(x);
}
protected int getValue() {
return i;
}
}
class Bar extends Foo {
int j;
Bar() {
j = 2;
}
@Override
protected int getValue() {
return j;
}
}
public class ConstructorExample {
public static void main(String... args) {
Bar bar = new Bar();
}
}

如果运行上面这段代码，会发现打印出来的结果既不是1，也不是2，而是0。根本原因就是Bar重载了Foo中的getValue方法。在执行Bar的构造函数是，编译器会为我们在Bar构造函数开头插入调用Foo的构造函数的代码，而在Foo的构造函数中调用了getValue方法。由于Java对构造函数的执行没有做特殊处理，因此这个getValue方法是被Bar重载的那个getValue方法，而在调用Bar的getValue方法时，Bar的构造函数还没有被执行，这个时候j的值还是默认值0，因此我们就看到了打印出来的0。

2.2. 实例变量初始化器与实例初始化器

我们可以在定义实例变量的同时，对实例变量进行赋值，赋值语句就时实例变量初始化器了，比如，

Java
1
2
3
4

public class InstanceVariableInitializer {
private int i = 1;
private int j = i + 1;
}

如果我们以这种方式为实例变量赋值，那么在构造函数执行之前会先完成这些初始化操作。

我们还可以通过实例初始化器来执行对象的初始化操作，比如，

Java
1
2
3
4
5
6
7
8
9

public class InstanceInitializer {
private int i = 1;
private int j;
{
j = 2;
}
}

上面代码中花括号内代码，在Java中就被称作实例初始化器，其中的代码同样会先于构造函数被执行。

如果我们定义了实例变量初始化器与实例初始化器，那么编译器会将其中的代码放到类的构造函数中去，这些代码会被放在对超类构造函数的调用语句之后(还记得吗？Java要求构造函数的第一条语句必须是超类构造函数的调用语句)，构造函数本身的代码之前。我们来看下下面这段Java代码被编译之后的字节码，Java代码如下，

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class InstanceInitializer {
private int i = 1;
private int j;
{
j = 2;
}
public InstanceInitializer() {
i = 3;
j = 4;
}
}

编译之后的字节码如下，

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

   aload_0
   invokespecial #11; //Method java/lang/Object."<init>":()V
   aload_0
   iconst_1
   putfield #13; //Field i:I
   aload_0
   iconst_2
   putfield #15; //Field j:I
   aload_0
   iconst_3
   putfield #13; //Field i:I
   aload_0
   iconst_4
   putfield #15; //Field j:I
   return

上面的字节码，第4，5行是执行的是源代码中i=1的操作，第6，7行执行的源代码中j=2的操作，第8-11行才是构造函数中i=3和j=4的操作。

Java是按照编程顺序来执行实例变量初始化器和实例初始化器中的代码的，并且不允许顺序靠前的实例初始化器或者实例变量初始化器使用在其后被定义和初始化的实例变量，比如，

Java
1
2
3
4
5
6
7
8
9
10
11
12
13

public class InstanceInitializer {
{
j = i;
}
private int i = 1;
private int j;
}
public class InstanceInitializer {
private int j = i;
private int i = 1;
}

上面的这些代码都是无法通过编译的，编译器会抱怨说我们使用了一个未经定义的变量。之所以要这么做，是为了保证一个变量在被使用之前已经被正确地初始化。但是我们仍然有办法绕过这种检查，比如，

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class InstanceInitializer {
private int j = getI();
private int i = 1;
public InstanceInitializer() {
i = 2;
}
private int getI() {
return i;
}
public static void main(String[] args) {
InstanceInitializer ii = new InstanceInitializer();
System.out.println(ii.j);
}
}

如果我们执行上面这段代码，那么会发现打印的结果是0。因此我们可以确信，变量j被赋予了i的默认值0，而不是经过实例变量初始化器和构造函数初始化之后的值。

引用

一个实例变量在对象初始化的过程中会被赋值几次？

在本文的前面部分，我们提到过，JVM在为一个对象分配完内存之后，会给每一个实例变量赋予默认值，这个时候实例变量被第一次赋值，这个赋值过程是没有办法避免的。

如果我们在实例变量初始化器中对某个实例x变量做了初始化操作，那么这个时候，这个实例变量就被第二次赋值了。

如果我们在实例初始化器中，又对变量x做了初始化操作，那么这个时候，这个实例变量就被第三次赋值了。

如果我们在类的构造函数中，也对变量x做了初始化操作，那么这个时候，变量x就被第四次赋值。

也就是说，一个实例变量，在Java的对象初始化过程中，最多可以被初始化4次。

2.3. 总结

通过上面的介绍，我们对Java中初始化对象的几种方式以及通过何种方式执行初始化代码有了了解，同时也对何种情况下我们可能会使用到未经初始化的变量进行了介绍。在对这些问题有了详细的了解之后，就可以在编码中规避一些风险，保证一个对象在可见之前是完全被初始化的。

3.关于类的初始化

Java规范中关于类在何时被初始化有详细的介绍，在3.0规范中的12.4.1节可以找到，这里就不再多说了。简单来说，就是当类被第一次使用的时候会被初始化，而且只会被一个线程初始化一次。我们可以通过静态初始化器和静态变量初始化器来完成对类变量的初始化工作，比如，

Java
1
2
3
4
5
6
7

public class StaticInitializer {
static int i = 1;
static {
i = 2;
}
}

上面通过两种方式对类变量i进行了赋值操作，分别通过静态变量初始化器(代码第2行)以及静态初始化器(代码第5-6行)完成。

静态变量初始化器和静态初始化器基本同实例变量初始化器和实例初始化器相同，也有相同的限制(按照编码顺序被执行，不能引用后定义和初始化的类变量)。静态变量初始化器和静态初始化器中的代码会被编译器放到一个名为static的方法中(static是Java语言的关键字，因此不能被用作方法名，但是JVM却没有这个限制)，在类被第一次使用时，这个static方法就会被执行。上面的Java代码编译之后的字节码如下，我们看到其中的static方法，

Java
1
2
3
4
5
6
7
8

static {};
  Code:
   Stack=1, Locals=0, Args_size=0
   iconst_1
   putstatic #10; //Field i:I
   iconst_2
   putstatic #10; //Field i:I
   return

在第2节中，我们介绍了可以通过特殊的方式来使用未经初始化的实例变量，对于类变量也同样适用，比如，

Java
1
2
3
4
5
6
7
8
9
10
11
12

public class StaticInitializer {
static int j = getI();
static int i = 1;
static int getI () {
return i;
}
public static void main(String[] args) {
System.out.println(StaticInitializer.j);
}
}

上面这段代码的打印结果是0，类变量的值是i的默认值0。但是，由于静态方法是不能被覆写的，因此第2节中关于构造函数调用被覆写方法引起的问题不会在此出现。

Java对象初始化详解相关推荐

  1. 64位JVM的Java对象头详解

    关注"Java艺术"一起来充电吧! 我们编写一个Java类,编译后会生成.class文件,当类加载器将class文件加载到jvm时,会生成一个Klass类型的对象(c++),称为类 ...

  2. java 初始化object_Java对象初始化详解

    出处:http://blog.jobbole.com/23939/ 在Java中,一个对象在可以被使用之前必须要被正确地初始化,这一点是Java规范规定的.本文试图对Java如何执行对象的初始化做一个 ...

  3. Java对象序列化详解

    下面的文章在公众号作了更新:点击查看最新文章 可识别二维码查看更多最新文章: 写在前面 Java对象是在JVM中生成的,如果需要远程传输或保存到硬盘上,就需要将Java对象转换成可传输的文件流. 市面 ...

  4. Java对象序列化详解6,Java对象的序列化与反序列化详解

    把对象转换为字节序列的过程称为对象的序列化,把字节序列恢复为对象的过程称为对象的反序列化. 对象的序列化主要有两种途径: Ⅰ . 把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中 Ⅱ.  在网 ...

  5. java对象克隆详解

    概述: 当我们new一个对象时,其中的属性就会被初始化, 那么想要保存刚开始初始化的值就靠clone方法来实现, 平时我们最常见的是一个对象的引用指向另一个对象,并不是创建了两个对象. Person ...

  6. Java 对象排序详解

    很难想象有Java开发人员不曾使用过Collection框架.在Collection框架中,主要使用的类是来自List接口中的ArrayList,以及来自Set接口的HashSet.TreeSet,我 ...

  7. Java对象深拷贝详解（List深拷贝）

    1.Java中拷贝的概念 在Java语言中,拷贝一个对象时,有浅拷贝与深拷贝两种 浅拷贝:只拷贝源对象的地址,所以新对象与老对象共用一个地址,当该地址变化时,两个对象也会随之改变. 深拷贝:拷贝对象的 ...

  8. java基础(十三)-----详解内部类——Java高级开发必须懂的

    java基础(十三)-----详解内部类--Java高级开发必须懂的 目录 为什么要使用内部类 内部类基础 静态内部类 成员内部类 成员内部类的对象创建 继承成员内部类 局部内部类 推荐博客 匿名内部 ...

  9. Java类加载机制详解【java面试题】

    Java类加载机制详解[java面试题] (1)问题分析: Class文件由类装载器装载后,在JVM中将形成一份描述Class结构的元信息对象,通过该元信息对象可以获知Class的结构信息:如构造函数 ...

最新文章

  1. Spring Cloud Alibaba源码 - 16 Nacos 注册中心源码解析
  2. 干货 | 图解 https 单向认证和双向认证！
  3. 卷积神经网络初步认知
  4. Struts2-day2总结
  5. 肝货满满！CV学习笔记：入坑必备
  6. 精彩回顾 | Apache Flink x Iceberg Meetup · 上海站
  7. 写入null_ArrayList并发写出现Null值
  8. 二十五.SLAM中Mapping和Localization区别和思考
  9. 虚拟化顶级技术会议KVM Forum演讲分享 | 移动云KVM共享云盘技术实践
  10. unity3d连接数据库
  11. 自写小函数处理 javascript 0.3*0.2 浮点类型相乘问题
  12. jackson json的使用
  13. 舆情分析系统技术解决方案及作用
  14. 如何迅速分析出系统CPU的瓶颈在哪里
  15. 机械制图及计算机绘图试题库,机械制图及计算机绘图--试题库2016版.pdf
  16. iOS 朋友圈点赞评论，发布朋友圈，想要的都有
  17. api es7 删除所有数据_【译】ECMAScript 2016 (ES7) 新特性一览
  18. TROY，加密资产新范式下的基础设施
  19. 下次激活策略10_实体店生意经：6招引流策略，引爆客流！可套用任何行业
  20. javaweb第三版课后答案，干货满满

热门文章

  1. 2022春节档新片预售总票房达1.08亿
  2. 三星Galaxy S22 Ultra真机首曝：颜值与实力并存堪称完美
  3. 外媒：特斯拉申请新商标 寻求进入餐饮业
  4. 行拘被释放，车顶维权女车主首发声！出手就是对特斯拉放大招？
  5. “跨界养猪”这件事，华为正式回应了
  6. 华为申请注册姚安娜商标
  7. 首发天玑1200！Redmi电竞旗舰首曝：电池容量或超4500mAh
  8. 社区团购“九不得”：低价倾销、大数据“杀熟”被禁止
  9. 因涉嫌信披违规 神州优车被证监会立案调查
  10. 停航63天！湖北复航了，机票预订火爆程度堪比春运