Java物件的建立：類別的初始化時機與過程

摘要：

在Java中，一個物件在可以被使用之前必須被正確地初始化，這一點是Java規格規定的。在實例化一個物件時，JVM首先會檢查相關類型是否已載入並初始化，如果沒有，則JVM立即進行載入並呼叫類別建構器完成類別的初始化。在類別初始化過程中或初始化完畢後，根據具體情況才會去對類別進行實例化。本文試圖對JVM執行類別初始化和實例化的過程做一個詳細深入介紹，以便從Java虛擬機器的角度清楚解剖一個Java物件的創建過程。

一.Java物件建立時機

我們知道，一個物件在可以被使用之前必須要被正確地實例化。在Java程式碼中，有很多行為可以引起對象的創建，最直觀的一種就是使用new關鍵字來調用一個類別的構造函數明確地創建對象，這種方式在Java規範中被稱為: 執行類別實例建立表達式所引起的物件建立。除此之外，我們還可以使用反射機制(Class類別的newInstance方法、使用Constructor類別的newInstance方法)、使用Clone方法、使用反序列化等方式建立物件。以下筆者分別對此進行一一介紹：

1). 使用new關鍵字建立物件

這是我們最常見的也是最簡單的建立物件的方式，透過這種方式我們可以呼叫任意的建構子（無參的和有參的）去創建物件。例如：

Student student = new Student();

2). 使用Class類別的newInstance方法(反射機制)

我們也可以透過Java的反射機制使用Class類別的newInstance方法來創建對象，事實上，這個newInstance方法呼叫無參的建構器來建立對象，例如：

Student student2 = (Student)Class.forName("Student类全限定名").newInstance();　
或者：
Student stu = Student.class.newInstance();

3). 使用Constructor類別的newInstance方法(反射機制)

#java.lang.relect.Constructor類別裡也有一個newInstance方法可以建立對象，該方法和Class類別中的newInstance方法很像，但是相較之下，Constructor類別的newInstance方法更加強大些，我們可以透過這個newInstance方法呼叫有參數的、私有的建構函數，例如：

public class Student {

   private int id;

   public Student(Integer id) {
       this.id = id;
   }

   public static void main(String[] args) throws Exception {

       Constructor<Student> constructor = Student.class
               .getConstructor(Integer.class);
       Student stu3 = constructor.newInstance(123);
   }
}

使用newInstance方法的這兩種方式創建物件使用的就是Java的反射機制，事實上Class的newInstance方法內部呼叫的也是Constructor的newInstance方法。

4). 使用Clone方法建立物件

無論何時我們呼叫一個物件的clone方法，JVM都會幫我們建立一個新的、一樣的對象，特別要說明的是，用clone方法建立物件的過程中並不會呼叫任何建構子。簡單而言，要使用clone方法，我們必須先實作Cloneable介面並實作其定義的clone方法，這也是原型模式的應用。例如：

public class Student implements Cloneable{

   private int id;

   public Student(Integer id) {
       this.id = id;
   }

   @Override
   protected Object clone() throws CloneNotSupportedException {
       // TODO Auto-generated method stub
       return super.clone();
   }

   public static void main(String[] args) throws Exception {

       Constructor<Student> constructor = Student.class
               .getConstructor(Integer.class);
       Student stu3 = constructor.newInstance(123);
       Student stu4 = (Student) stu3.clone();
   }
}

5). 使用(反)序列化機制建立物件

當我們反序列化一個物件時，JVM會為我們建立一個單獨的對象，在此過程中，JVM並不會呼叫任何建構子。為了反序列化一個對象，我們需要讓我們的類別實作Serializable接口，例如：

public class Student implements Cloneable, Serializable {

   private int id;

   public Student(Integer id) {
       this.id = id;
   }

   @Override
   public String toString() {
       return "Student [id=" + id + "]";
   }

   public static void main(String[] args) throws Exception {

       Constructor<Student> constructor = Student.class
               .getConstructor(Integer.class);
       Student stu3 = constructor.newInstance(123);

       // 写对象
       ObjectOutputStream output = new ObjectOutputStream(
               new FileOutputStream("student.bin"));
       output.writeObject(stu3);
       output.close();

       // 读对象
       ObjectInputStream input = new ObjectInputStream(new FileInputStream(
               "student.bin"));
       Student stu5 = (Student) input.readObject();
       System.out.println(stu5);
   }
}

6). 完整實例

public class Student implements Cloneable, Serializable {

   private int id;

   public Student() {

   }

   public Student(Integer id) {
       this.id = id;
   }

   @Override
   protected Object clone() throws CloneNotSupportedException {
       // TODO Auto-generated method stub
       return super.clone();
   }

   @Override
   public String toString() {
       return "Student [id=" + id + "]";
   }

   public static void main(String[] args) throws Exception {

       System.out.println("使用new关键字创建对象：");
       Student stu1 = new Student(123);
       System.out.println(stu1);
       System.out.println("\n---------------------------\n");


       System.out.println("使用Class类的newInstance方法创建对象：");
       Student stu2 = Student.class.newInstance();    //对应类必须具有无参构造方法，且只有这一种创建方式
       System.out.println(stu2);
       System.out.println("\n---------------------------\n");

       System.out.println("使用Constructor类的newInstance方法创建对象：");
       Constructor<Student> constructor = Student.class
               .getConstructor(Integer.class);   // 调用有参构造方法
       Student stu3 = constructor.newInstance(123);   
       System.out.println(stu3);
       System.out.println("\n---------------------------\n");

       System.out.println("使用Clone方法创建对象：");
       Student stu4 = (Student) stu3.clone();
       System.out.println(stu4);
       System.out.println("\n---------------------------\n");

       System.out.println("使用(反)序列化机制创建对象：");
       // 写对象
       ObjectOutputStream output = new ObjectOutputStream(
               new FileOutputStream("student.bin"));
       output.writeObject(stu4);
       output.close();

       // 读取对象
       ObjectInputStream input = new ObjectInputStream(new FileInputStream(
               "student.bin"));
       Student stu5 = (Student) input.readObject();
       System.out.println(stu5);

   }
}/* Output: 
       使用new关键字创建对象：
       Student [id=123]

       ---------------------------

       使用Class类的newInstance方法创建对象：
       Student [id=0]

       ---------------------------

       使用Constructor类的newInstance方法创建对象：
       Student [id=123]

       ---------------------------

       使用Clone方法创建对象：
       Student [id=123]

       ---------------------------

       使用(反)序列化机制创建对象：
       Student [id=123]
*///:~

 從Java虛擬機層面看，除了使用new關鍵字建立物件的方式外，其他方式全部都是透過轉變為invokevirtual指令直接建立物件的。

二. Java 物件的建立過程

當一個物件被建立時，虛擬機器就會為其分配記憶體來存放物件自己的實例變數及其從父類別繼承過來的實例變數(即使這些從超類別繼承過來的實例變數有可能被隱藏也會被分配空間)。 在為這些實例變數分配記憶體的同時，這些實例變數也會被賦予預設值(零值)。 在記憶體分配完成之後，Java虛擬機器就會開始對新建立的物件依照程式猿的意志進行初始化。在Java物件初始化過程中，主要涉及三種執行物件初始化的結構，分別是 實例變數初始化、實例程式碼區塊初始化 、 建構函數初始化。

1、實例變數初始化與實例程式碼區塊初始化

我們在定義（宣告）實例變數的同時，也可以直接對實例變數進行賦值或使用實例程式碼區塊對其進行賦值。如果我們以這兩種方式為實例變數進行初始化，那麼它們將在建構函式執行之前完成這些初始化操作。 實際上，如果我們對實例變數直接賦值或使用實例程式碼區塊賦值，那麼編譯器會將其中的程式碼放到類別的建構函式中去，並且這些程式碼會被放在對超類別建構函式的呼叫語句之後(還記得嗎？Java要求建構函式的第一個語句必須是超類別建構函式的呼叫語句)，在建構函式本身的程式碼之前。 例如：

public class InstanceVariableInitializer {  

   private int i = 1;  
   private int j = i + 1;  

   public InstanceVariableInitializer(int var){
       System.out.println(i);
       System.out.println(j);
       this.i = var;
       System.out.println(i);
       System.out.println(j);
   }

   {               // 实例代码块
       j += 3; 

   }

   public static void main(String[] args) {
       new InstanceVariableInitializer(8);
   }
}/* Output: 
           1
           5
           8
           5
*///:~

上面的例子正好印证了上面的结论。特别需要注意的是，Java是按照编程顺序来执行实例变量初始化器和实例初始化器中的代码的，并且不允许顺序靠前的实例代码块初始化在其后面定义的实例变量，比如：

public class InstanceInitializer {  
   {  
       j = i;  
   }  

   private int i = 1;  
   private int j;  
}  

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

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

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，这一动作发生在实例变量i初始化之前和构造函数调用之前。

2、构造函数初始化

我们可以从上文知道，实例变量初始化与实例代码块初始化总是发生在构造函数初始化之前，那么我们下面着重看看构造函数初始化过程。众所周知，每一个Java中的对象都至少会有一个构造函数，如果我们没有显式定义构造函数，那么它将会有一个默认无参的构造函数。在编译生成的字节码中，这些构造函数会被命名成()方法，参数列表与Java语言书写的构造函数的参数列表相同。

我们知道，Java要求在实例化类之前，必须先实例化其超类，以保证所创建实例的完整性。事实上，这一点是在构造函数中保证的：Java强制要求Object对象(Object是Java的顶层对象，没有超类)之外的所有对象构造函数的第一条语句必须是超类构造函数的调用语句或者是类中定义的其他的构造函数，如果我们既没有调用其他的构造函数，也没有显式调用超类的构造函数，那么编译器会为我们自动生成一个对超类构造函数的调用，比如：

public class ConstructorExample {  

}

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

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

上面代码的第二行就是调用Object类的默认构造函数的指令。也就是说，如果我们显式调用超类的构造函数，那么该调用必须放在构造函数所有代码的最前面，也就是必须是构造函数的第一条指令。正因为如此，Java才可以使得一个对象在初始化之前其所有的超类都被初始化完成，并保证创建一个完整的对象出来。

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

public class ConstructorExample {  
   private int i;  

   ConstructorExample() {  
       this(1);  
       ....  
   }  

   ConstructorExample(int i) {  
       ....  
       this.i = i;  
       ....  
   }  
}

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

public class ConstructorExample {  
   private int i;  

   ConstructorExample() {  
       super();  
       this(1);  // Error:Constructor call must be the first statement in a constructor
       ....  
   }  

   ConstructorExample(int i) {  
       ....  
       this.i = i;  
       ....  
   }  
}

或者，

public class ConstructorExample {  
   private int i;  

   ConstructorExample() {  
       this(1);  
       super();  //Error: Constructor call must be the first statement in a constructor
       ....  
   }  

   ConstructorExample(int i) {  
       this.i = i;  
   }  
}

Java通过对构造函数作出这种限制以便保证一个类的实例能够在被使用之前正确地初始化。

3、 小结

　　总而言之，实例化一个类的对象的过程是一个典型的递归过程，如下图所示。进一步地说，在实例化一个类的对象时，具体过程是这样的：

　　在准备实例化一个类的对象前，首先准备实例化该类的父类，如果该类的父类还有父类，那么准备实例化该类的父类的父类，依次递归直到递归到Object类。此时，首先实例化Object类，再依次对以下各类进行实例化，直到完成对目标类的实例化。具体而言，在实例化每个类时，都遵循如下顺序：先依次执行实例变量初始化和实例代码块初始化，再执行构造函数初始化。也就是说，编译器会将实例变量初始化和实例代码块初始化相关代码放到类的构造函数中去，并且这些代码会被放在对超类构造函数的调用语句之后，构造函数本身的代码之前。

4、实例变量初始化、实例代码块初始化以及构造函数初始化综合实例

//父类
class Foo {
   int i = 1;

   Foo() {
       System.out.println(i);             -----------(1)
       int x = getValue();
       System.out.println(x);             -----------(2)
   }

   {
       i = 2;
   }

   protected int getValue() {
       return i;
   }
}

//子类
class Bar extends Foo {
   int j = 1;

   Bar() {
       j = 2;
   }

   {
       j = 3;
   }

   @Override
   protected int getValue() {
       return j;
   }
}

public class ConstructorExample {
   public static void main(String... args) {
       Bar bar = new Bar();
       System.out.println(bar.getValue());             -----------(3)
   }
}/* Output: 
           2
           0
           2
*///:~

根据上文所述的类实例化过程，我们可以将Foo类的构造函数和Bar类的构造函数等价地分别变为如下形式：

//Foo类构造函数的等价变换：
   Foo() {
       i = 1;
       i = 2;
       System.out.println(i);
       int x = getValue();
       System.out.println(x);
   }

//Bar类构造函数的等价变换
   Bar() {
       Foo();
       j = 1;
       j = 3;
       j = 2
   }

这样程序就好看多了，我们一眼就可以观察出程序的输出结果。在通过使用Bar类的构造方法new一个Bar类的实例时，首先会调用Foo类构造函数，因此(1)处输出是2，这从Foo类构造函数的等价变换中可以直接看出。(2)处输出是0，为什么呢？因为在执行Foo的构造函数的过程中，由于Bar重载了Foo中的getValue方法，所以根据Java的多态特性可以知道，其调用的getValue方法是被Bar重载的那个getValue方法。但由于这时Bar的构造函数还没有被执行，因此此时j的值还是默认值0，因此(2)处输出是0。最后，在执行(3)处的代码时，由于bar对象已经创建完成，所以此时再访问j的值时，就得到了其初始化后的值2，这一点可以从Bar类构造函数的等价变换中直接看出。

三. 类的初始化时机与过程

　　简单地说，在类加载过程中，准备阶段是正式为类变量(static 成员变量)分配内存并设置类变量初始值（零值）的阶段，而初始化阶段是真正开始执行类中定义的java程序代码(字节码)并按程序猿的意图去初始化类变量的过程。更直接地说，初始化阶段就是执行类构造器()方法的过程。()方法是由编译器自动收集类中的所有类变量的赋值动作和静态代码块static{}中的语句合并产生的，其中编译器收集的顺序是由语句在源文件中出现的顺序所决定。

　　类构造器()与实例构造器()不同，它不需要程序员进行显式调用，虚拟机会保证在子类类构造器()执行之前，父类的类构造()执行完毕。由于父类的构造器()先执行，也就意味着父类中定义的静态代码块/静态变量的初始化要优先于子类的静态代码块/静态变量的初始化执行。特别地，类构造器()对于类或者接口来说并不是必需的，如果一个类中没有静态代码块，也没有对类变量的赋值操作，那么编译器可以不为这个类生产类构造器()。此外，在同一个类加载器下，一个类只会被初始化一次，但是一个类可以任意地实例化对象。也就是说，在一个类的生命周期中，类构造器()最多会被虚拟机调用一次，而实例构造器()则会被虚拟机调用多次，只要程序员还在创建对象。

　　注意，这里所谓的实例构造器()是指收集类中的所有实例变量的赋值动作、实例代码块和构造函数合并产生的，类似于上文对Foo类的构造函数和Bar类的构造函数做的等价变换。

四. 总结

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

　　我们知道，JVM在为一个对象分配完内存之后，会给每一个实例变量赋予默认值，这个时候实例变量被第一次赋值，这个赋值过程是没有办法避免的。如果我们在声明实例变量x的同时对其进行了赋值操作，那么这个时候，这个实例变量就被第二次赋值了。如果我们在实例代码块中，又对变量x做了初始化操作，那么这个时候，这个实例变量就被第三次赋值了。如果我们在构造函数中，也对变量x做了初始化操作，那么这个时候，变量x就被第四次赋值。也就是说，在Java的对象初始化过程中，一个实例变量最多可以被初始化4次。

2、类的初始化过程与类的实例化过程的异同？

　　类的初始化是指类加载过程中的初始化阶段对类变量按照程序猿的意图进行赋值的过程；而类的实例化是指在类完全加载到内存中后创建对象的过程。

3、假如一个类还未加载到内存中，那么在创建一个该类的实例时，具体过程是怎样的？

　　我们知道，要想创建一个类的实例，必须先将该类加载到内存并进行初始化，也就是说，类初始化操作是在类实例化操作之前进行的，但并不意味着：只有类初始化操作结束后才能进行类实例化操作。

public class StaticTest {
   public static void main(String[] args) {
       staticFunction();
   }

   static StaticTest st = new StaticTest();

   static {   //静态代码块
       System.out.println("1");
   }

   {       // 实例代码块
       System.out.println("2");
   }

   StaticTest() {    // 实例构造器
       System.out.println("3");
       System.out.println("a=" + a + ",b=" + b);
   }

   public static void staticFunction() {   // 静态方法
       System.out.println("4");
   }

   int a = 110;    // 实例变量
   static int b = 112;     // 静态变量
}/* Output: 
       2
       3
       a=110,b=0
       1
       4
*///:~

 总的来说，类实例化的一般过程是：父类的类构造器() -> 子类的类构造器() -> 父类的成员变量和实例代码块 -> 父类的构造函数 -> 子类的成员变量和实例代码块 -> 子类的构造函数。

相关推荐：

java对象初始化的顺序

初始化java物件的順序

#

以上是Java物件的建立：類別的初始化時機與過程的詳細內容。更多資訊請關注PHP中文網其他相關文章！