黑马程序员技术交流社区

标题: Java对象初始化详解 [打印本页]
作者: 丁夏宁    时间: 2014-9-4 21:47
标题: Java对象初始化详解
本帖最后由 丁夏宁 于 2014-9-4 21:55 编辑

来源：MySun http://mysun.iteye.com/blog/1596959
在Java中，一个对象在可以被使用之前必须要被正确地初始化，这一点是Java规范规定的。本文试图对Java如何执行对象的初始化做一个详细深入地介绍(与对象初始化相同，类在被加载之后也是需要初始化的，本文在最后也会对类的初始化进行介绍，相对于对象初始化来说，类的初始化要相对简单一些)。
1.Java对象何时被初始化
Java对象在其被创建时初始化，在Java代码中，有两种行为可以引起对象的创建。其中比较直观的一种，也就是通常所说的显式对象创建，就是通过new关键字来调用一个类的构造函数，通过构造函数来创建一个对象，这种方式在java规范中被称为“由执行类实例创建表达式而引起的对象创建”。
当然，除了显式地创建对象，以下的几种行为也会引起对象的创建，但是并不是通过new关键字来完成的，因此被称作隐式对象创建，他们分别是：
  1. class StringLiteral {  
  2.     private String str = "literal";  
  3.     private static String sstr = "s_literal";   
  4. }  
复制代码
  1. class PrimitiveWrapper {  
  2.     private Integer iWrapper = 1;  
  3. }  
复制代码
  1. public class StringConcatenation {  
  2.     private static int i = 1;  

  4.     public static void main(String... args) {  
  5.         System.out.println("literal" + i);  
  6.     }  
  7. }  
复制代码
2.Java如何初始化对象
当一个对象被创建之后，虚拟机会为其分配内存，主要用来存放对象的实例变量及其从超类继承过来的实例变量(即使这些从超类继承过来的实例变量有可能被隐藏也会被分配空间)。在为这些实例变量分配内存的同时，这些实例变量也会被赋予默认值。
关于实例变量隐藏
  1. class Foo {  
  2.     int i = 0;  
  3. }  
  4.   
  5. class Bar extends Foo {  
  6.     int i = 1;  
  7.     public static void main(String... args) {  
  8.         Foo foo = new Bar();  
  9.         System.out.println(foo.i);  
  10.     }  
  11. }  
复制代码


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

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


作者: 丁夏宁    时间: 2014-9-4 22:04
本帖最后由 丁夏宁 于 2014-9-4 22:06 编辑

2.1. Java的构造函数
每一个Java中的对象都至少会有一个构造函数，如果我们没有显式定义构造函数，那么Java编译器会为我们自动生成一个构造函数。构造函数与类中定义的其他方法基本一样，除了构造函数没有返回值，名字与类名一样之外。在生成的字节码中，这些构造函数会被命名成方法，参数列表与Java语言书写的构造函数的参数列表相同(这样的方法名在Java语言中是非法的，但是对于JVM来说，是合法的)。另外，构造函数也可以被重载。
Java要求一个对象被初始化之前，其超类也必须被初始化，这一点是在构造函数中保证的。Java强制要求Object对象(Object是Java的顶层对象，没有超类)之外的所有对象构造函数的第一条语句必须是超类构造函数的调用语句或者是类中定义的其他的构造函数，如果我们即没有调用其他的构造函数，也没有显式调用超类的构造函数，那么编译器会为我们自动生成一个对超类构造函数的调用指令，比如，
  1. public class ConstructorExample {  
  2.       
  3. }  
复制代码
对于上面代码中定义的类，如果观察编译之后的字节码，我们会发现编译器为我们生成一个构造函数，如下，
  1. aload_0  
  2. invokespecial   #8; //Method java/lang/Object."<init>":()V  
  3. return  
复制代码
上面代码的第二行就是调用Object对象的默认构造函数的指令。
正因为如此，如果我们显式调用超类的构造函数，那么调用指令必须放在构造函数所有代码的最前面，是构造函数的第一条指令。这么做才可以保证一个对象在初始化之前其所有的超类都被初始化完成。
如果我们在一个构造函数中调用另外一个构造函数，如下所示，
  1. public class ConstructorExample {  
  2.     private int i;  
  3.       
  4.     ConstructorExample() {  
  5.         this(1);  
  6.         ....  
  7.     }  
  8.       
  9.     ConstructorExample(int i) {  
  10.         ....  
  11.         this.i = i;  
  12.         ....  
  13.     }  
  14. }  
复制代码

对于这种情况，Java只允许在ConstructorExample(int i)内出现调用超类的构造函数，也就是说，下面的代码编译是无法通过的，
  1. public class ConstructorExample {  
  2.     private int i;  
  3.       
  4.     ConstructorExample() {  
  5.         super();  
  6.         this(1);  
  7.         ....  
  8.     }  
  9.       
  10.     ConstructorExample(int i) {  
  11.         ....  
  12.         this.i = i;  
  13.         ....  
  14.     }  
  15. }  
复制代码

或者，
  1. public class ConstructorExample {  
  2.     private int i;  
  3.       
  4.     ConstructorExample() {  
  5.         this(1);  
  6.         super();  
  7.         ....  
  8.     }  
  9.       
  10.     ConstructorExample(int i) {  
  11.         ....  
  12.         this.i = i;  
  13.         ....  
  14.     }  
  15. }  
复制代码

Java对构造函数作出这种限制，目的是为了要保证一个类中的实例变量在被使用之前已经被正确地初始化，不会导致程序执行过程中的错误。但是，与C或者C++不同，Java执行构造函数的过程与执行其他方法并没有什么区别，因此，如果我们不小心，有可能会导致在对象的构建过程中使用了没有被正确初始化的实例变量，如下所示，
  1. class Foo {  
  2.     int i;  
  3.       
  4.     Foo() {  
  5.         i = 1;  
  6.         int x = getValue();  
  7.         System.out.println(x);  
  8.     }  
  9.       
  10.     protected int getValue() {  
  11.         return i;  
  12.     }  
  13. }  
  14.   
  15. class Bar extends Foo {  
  16.     int j;  
  17.       
  18.     Bar() {  
  19.         j = 2;  
  20.     }  
  21.       
  22.     @Override  
  23.     protected int getValue() {  
  24.         return j;  
  25.     }  
  26. }  
  27.   
  28. public class ConstructorExample {  
  29.     public static void main(String... args) {  
  30.         Bar bar = new Bar();  
  31.     }  
  32. }  
复制代码
如果运行上面这段代码，会发现打印出来的结果既不是1，也不是2，而是0。根本原因就是Bar重载了Foo中的getValue方法。在执行Bar的构造函数是，编译器会为我们在Bar构造函数开头插入调用Foo的构造函数的代码，而在Foo的构造函数中调用了getValue方法。由于Java对构造函数的执行没有做特殊处理，因此这个getValue方法是被Bar重载的那个getValue方法，而在调用Bar的getValue方法时，Bar的构造函数还没有被执行，这个时候j的值还是默认值0，因此我们就看到了打印出来的0。




作者: 丁夏宁    时间: 2014-9-4 22:12
2.2. 实例变量初始化器与实例初始化器
我们可以在定义实例变量的同时，对实例变量进行赋值，赋值语句就时实例变量初始化器了，比如，
  1. public class InstanceVariableInitializer {  
  2.     private int i = 1;  
  3.     private int j = i + 1;  
  4. }  
复制代码

如果我们以这种方式为实例变量赋值，那么在构造函数执行之前会先完成这些初始化操作。
我们还可以通过实例初始化器来执行对象的初始化操作，比如，
  1. public class InstanceInitializer {  
  2.       
  3.     private int i = 1;  
  4.     private int j;  
  5.       
  6.     {  
  7.         j = 2;  
  8.     }  
  9. }  
复制代码
上面代码中花括号内代码，在Java中就被称作实例初始化器，其中的代码同样会先于构造函数被执行。
如果我们定义了实例变量初始化器与实例初始化器，那么编译器会将其中的代码放到类的构造函数中去，这些代码会被放在对超类构造函数的调用语句之后(还记得吗？Java要求构造函数的第一条语句必须是超类构造函数的调用语句)，构造函数本身的代码之前。我们来看下下面这段Java代码被编译之后的字节码，Java代码如下，
  1. public class InstanceInitializer {  
  2.       
  3.     private int i = 1;  
  4.     private int j;  
  5.       
  6.     {  
  7.         j = 2;  
  8.     }  
  9.       
  10.     public InstanceInitializer() {  
  11.         i = 3;  
  12.         j = 4;  
  13.     }  
  14. }  
复制代码
编译之后的字节码如下，
  1. aload_0  
  2. invokespecial   #11; //Method java/lang/Object."<init>":()V  
  3. aload_0  
  4. iconst_1  
  5. putfield    #13; //Field i:I  
  6. aload_0  
  7. iconst_2  
  8. putfield    #15; //Field j:I  
  9. aload_0  
  10. iconst_3  
  11. putfield    #13; //Field i:I  
  12. aload_0  
  13. iconst_4  
  14. putfield    #15; //Field j:I  
  15. return  
复制代码

上面的字节码，第4，5行是执行的是源代码中i=1的操作，第6，7行执行的源代码中j=2的操作，第8-11行才是构造函数中i=3和j=4的操作。
Java是按照编程顺序来执行实例变量初始化器和实例初始化器中的代码的，并且不允许顺序靠前的实例初始化器或者实例变量初始化器使用在其后被定义和初始化的实例变量，比如，
  1. public class InstanceInitializer {  
  2.     {  
  3.         j = i;  
  4.     }  
  5.       
  6.     private int i = 1;  
  7.     private int j;  
  8. }  
  9.   
  10. public class InstanceInitializer {  
  11.     private int j = i;  
  12.     private int i = 1;  
  13. }  
复制代码

上面的这些代码都是无法通过编译的，编译器会抱怨说我们使用了一个未经定义的变量。之所以要这么做，是为了保证一个变量在被使用之前已经被正确地初始化。但是我们仍然有办法绕过这种检查，比如，
  1. public class InstanceInitializer {  
  2.     private int j = getI();  
  3.     private int i = 1;  
  4.       
  5.     public InstanceInitializer() {  
  6.         i = 2;  
  7.     }  
  8.       
  9.     private int getI() {  
  10.         return i;  
  11.     }  
  12.       
  13.     public static void main(String[] args) {  
  14.         InstanceInitializer ii = new InstanceInitializer();  
  15.         System.out.println(ii.j);  
  16.     }  
  17. }  
复制代码

如果我们执行上面这段代码，那么会发现打印的结果是0。因此我们可以确信，变量j被赋予了i的默认值0，而不是经过实例变量初始化器和构造函数初始化之后的值。
一个实例变量在对象初始化的过程中会被赋值几次？
在本文的前面部分，我们提到过，JVM在为一个对象分配完内存之后，会给每一个实例变量赋予默认值，这个时候实例变量被第一次赋值，这个赋值过程是没有办法避免的。
如果我们在实例变量初始化器中对某个实例x变量做了初始化操作，那么这个时候，这个实例变量就被第二次赋值了。
如果我们在实例初始化器中，又对变量x做了初始化操作，那么这个时候，这个实例变量就被第三次赋值了。
如果我们在类的构造函数中，也对变量x做了初始化操作，那么这个时候，变量x就被第四次赋值。
也就是说，一个实例变量，在Java的对象初始化过程中，最多可以被初始化4次。


作者: 丁夏宁    时间: 2014-9-4 22:16
2.3. 总结
通过上面的介绍，我们对Java中初始化对象的几种方式以及通过何种方式执行初始化代码有了了解，同时也对何种情况下我们可能会使用到未经初始化的变量进行了介绍。在对这些问题有了详细的了解之后，就可以在编码中规避一些风险，保证一个对象在可见之前是完全被初始化的。 [
3.关于类的初始化
Java规范中关于类在何时被初始化有详细的介绍，在3.0规范中的12.4.1节可以找到，这里就不再多说了。简单来说，就是当类被第一次使用的时候会被初始化，而且只会被一个线程初始化一次。我们可以通过静态初始化器和静态变量初始化器来完成对类变量的初始化工作，比如，
  1. public class StaticInitializer {  
  2.     static int i = 1;  
  3.       
  4.     static {  
  5.         i = 2;  
  6.     }  
  7. }  
复制代码

上面通过两种方式对类变量i进行了赋值操作，分别通过静态变量初始化器(代码第2行)以及静态初始化器(代码第5-6行)完成。
静态变量初始化器和静态初始化器基本同实例变量初始化器和实例初始化器相同，也有相同的限制(按照编码顺序被执行，不能引用后定义和初始化的类变量)。静态变量初始化器和静态初始化器中的代码会被编译器放到一个名为static的方法中(static是Java语言的关键字，因此不能被用作方法名，但是JVM却没有这个限制)，在类被第一次使用时，这个static方法就会被执行。上面的Java代码编译之后的字节码如下，我们看到其中的static方法，
  1. static {};  
  2.   Code:  
  3.    Stack=1, Locals=0, Args_size=0  
  4.    iconst_1  
  5.    putstatic    #10; //Field i:I  
  6.    iconst_2  
  7.    putstatic    #10; //Field i:I  
  8.    return  
复制代码

在第2节中，我们介绍了可以通过特殊的方式来使用未经初始化的实例变量，对于类变量也同样适用，比如，
  1. public class StaticInitializer {  
  2.     static int j = getI();  
  3.     static int i = 1;  
  4.       
  5.     static int getI () {  
  6.         return i;  
  7.     }  
  8.       
  9.     public static void main(String[] args) {  
  10.         System.out.println(StaticInitializer.j);  
  11.     }  
  12. }  
复制代码

上面这段代码的打印结果是0，类变量的值是i的默认值0。但是，由于静态方法是不能被覆写的，因此第2节中关于构造函数调用被覆写方法引起的问题不会在此出现。
作者: 648947721    时间: 2014-9-5 01:04
挺详细的，学习学习。
作者: lq你微笑时好美    时间: 2014-9-5 08:17
赞，最近正在这晕了，好好看看
作者: wfaly    时间: 2014-9-5 09:06
谢谢 楼主 ...分享
作者: F@C    时间: 2014-9-5 16:18
进来学习
作者: 小糊涂神    时间: 2014-9-5 18:49
学习了，给力。
作者: fouraa    时间: 2014-9-6 17:54
好晕！！！
作者: air鹏    时间: 2014-9-6 18:34
总结的很详细 谢谢分享
作者: 进击的大鹏    时间: 2014-9-6 22:19
很详细，收藏了
作者: 谢建平    时间: 2014-9-7 06:28
学习 学习
作者: 彭卫红    时间: 2014-9-7 07:09
学习了。。。。
作者: 男人你得有范    时间: 2014-9-7 07:15
我是专门搞收藏的，哈哈



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2