大家都知道，Java是站在巨人的肩上成功的，它是在C&C++的基礎上進一步的開發，投入面向物件開發的懷抱。Java吸取了很多以前的教訓，加入自己很多獨創的方式。在程式語言發展初期，許多C程式設計師經常忘記初始化變數，在程式結束後也經常忘記對建立的資料型別進行釋放記憶體，造成記憶體洩漏。這些"不安全"的程式設計方式當然需要程式設計師有良好的程式設計習慣，但如果程式語言能夠加入自動清理與初始化的工作，這回大大降低開發成本。隨著技術的發展，C++語言引入了構造器（constructor），即在建立物件自動呼叫的初識方法，Java語言採用這一方法，並加入垃圾回收器，負責自動回收使用者建立的記憶體，進一步降低程式設計師的開發成本。

Java的初始化與構造器

　　建立Java的物件最普遍發的方法是使用new方法，如下所示。而建立物件必須使用構造器，構造器實際就是Java物件初始化的方法，使用者可以在該方法中新增自定義初始化行為。

 Object obj = new Object(); // 左側為宣告物件，右側為實際建立一個物件

　　構造器它是一個隱含為靜態的無返回值的方法，名稱與類名相同，編譯期會自動呼叫該方法。如果使用者沒有建立構造器，編譯期會為你自動生成一個預設構造器。總之，構造器個數至少有一個。構造器可以有多個，它可以使用者自己選擇如何初始化物件，這裡是使用過載（Overload）的方法。如下所示：

package com.thinkinjava.initialization;
import static com.thinkinjava.util.Print.*;

class Tree {
 int height;
 Tree() {
 print("Planting a seedling");
 height = 0;
 }
 Tree(int initialHeight) {
 height = initialHeight;
 print("Creating new Tree that is " +
  height + " feet tall");
 } 
 void info() {
 print("Tree is " + height + " feet tall");
 }
 void info(String s) {
 print(s + ": Tree is " + height + " feet tall");
 }
}

public class Overloading {
 public static void main(String[] args) {
 for(int i = 0; i < 5; i++) {
  Tree t = new Tree(i);
  t.info();
  t.info("overloaded method");
 }
 // Overloaded constructor:
 new Tree();
 } 
}

Java的初始化順序

　　既然講到Java初始化，那肯定要關注Java的初始化順序，這涉及到一些繼承的知識，首先看一個例項：

package com.thinkinjava.multiplex;

import static com.thinkinjava.util.Print.print;

/**
 * 初始化順序
 *
 */

// 形狀
class Insect {
  private int i = 9;
  protected int j;
  private int k = priInit("Insect.k initialized");

  Insect() {
    print("i = " + i + ",j = " + j);
    j = 39;
  }

  private static int x1 = priInit("static Insect.x1 initialized");

  static int priInit(String s) {
    print(s);
    return 47;
  }
}

class InitOrder extends Insect {
  private int i = 10;
  private int k = priInit("InitOrder.k initialized");

  public InitOrder() {
    print(" k = " + k);
    print(" j = " + j);
  }

  private static int x2 = priInit("static InitOrder.x2 initialized");

  public static void main(String[] args) {
    print("InitOrder constructor");
    InitOrder x = new InitOrder();
  }
}

Output:

static Insect.x1 initialized
static InitOrder.x2 initialized
InitOrder constructor
Insect.k initialized
i = 9,j = 0
InitOrder.k initialized
k = 47
j = 39

　　如上所示，當執行該Java程式時，首先訪問程式入口，即InitOrder.main()方法，於是類載入器載入InitOrder.class類檔案，而對它的載入過程中，通過extends關鍵字可知該類有個父類，於是載入該父類，如果該父類還有它自身的父類，繼續載入，然後執行最高一層類的static初始化，然後是其子類，依次執行，最後所有的類的已載入完成，開始執行main方法：在main方法中開始建立物件，物件被建立之後，虛擬機器會為其分配記憶體，主要用來存放物件的例項變數及其從父類繼承過來的例項變數(即使這些從父類繼承過來的例項變數有可能被隱藏也會被分配空間)。在為這些例項變數分配記憶體的同時，這些例項變數也會被賦予預設值。在記憶體中建立物件後，開始呼叫父類的構造器，父類的構造器能夠使用super呼叫或被編譯期自動呼叫，父類在執行構造器語句之前，會對父類例項變數按照次序進行初始化。父類完成父類子物件的初始化後，子類開始的順序執行，先例項變數初始化，然後執行構造器語句。最後整個物件構造完成。

Java的物件與清理

　　Java的顯著優點就是Java有良好的垃圾清理機制，C++中建立物件，使用物件後，需要使用delete操作符刪除物件，就會呼叫對應的解構函式。而Java中沒有解構函式，Java的finalize()並不是類似C++的解構函式，Java的finalize()只是用來回收本地方法（c/c++）佔用的記憶體（呼叫本地方法類似free）。通常意義上來講，Java程式設計師只需建立物件，而不需我們自己去銷燬物件，因為垃圾回收機制會幫我們回收物件，雖然不知道什麼時候回收，是否會被回收。

　　然後可能會出現這種情況，類可能要在生命週期內執行一些必需的清理活動，這就需要程式設計師自己書寫清理方法，在清理方法中必須注意清理順序，即其順序與初始化順序相反，為防止出現異常，可以將清理動作放入finally中。如例項所示：

import static com.thinkinjava.util.Print.print;

/**
 * 確保正確清理
 * */

// 形狀
class Shape {
 Shape(int i) {
 print("Shape constructor");
 }

 // 處理
 void dispose() {
 print("Shape dispose");
 }
}

class Circle extends Shape {
 Circle(int i) {
 super(i);
 print("Circle constructor");
 }

 void dispose() {
 print("Circle dispose");
 super.dispose();
 }
}

// 三角形
class Triangle extends Shape {
 Triangle(int i) {
 super(i);
 print("Triangle constructor");
 }

 void dispose() {
 print("Triangle dispose");
 super.dispose();
 }
}

class Line extends Shape {
 private int start,end;

 Line(int start,int end) {
 super(start);
 this.start = start;
 this.end = end;
 print("Drawing Line: " + start + "," + end);
 }

 void dispose() {
 // 擦除線條
 print("Erasing Line: " + start + "," + end);
 super.dispose();
 }
}

public class CADSystem extends Shape {
 private Circle c;
 private Triangle t;
 private Line[] lines = new Line[3];

 public CADSystem(int i) {
 super(i + 1);
 for (int j = 0; j < lines.length; j++) {
  lines[j] = new Line(j,j * j);
 }
 c = new Circle(1);
 t = new Triangle(1);
 print("Combined constructor");
 }

 public void dispose() {
 print("CADSystem.dispose()");
 // 清理的順序與初始化順序相反
 t.dispose();
 c.dispose();
 for (int i = lines.length - 1; i >= 0; i--) {
  lines[i].dispose();
 }
 super.dispose();
 }

 public static void main(String[] args) {
 CADSystem x = new CADSystem(47);
 try {
  // 程式編碼與異常處理
 } finally {
  x.dispose();
 }
 }

Output:

Shape constructor
Shape constructor
Drawing Line: 0,0
Shape constructor
Drawing Line: 1,1
Shape constructor
Drawing Line: 2,4
Shape constructor
Circle constructor
Shape constructor
Triangle constructor
Combined constructor
CADSystem.dispose()
Triangle dispose
Shape dispose
Circle dispose
Shape dispose
Erasing Line: 2,4
Shape dispose
Erasing Line: 1,1
Shape dispose
Erasing Line: 0,0
Shape dispose
Shape dispose*/

以上就是詳解Java的初始化與清理的詳細內容，更多關於Java的初始化與清理的資料請關注我們其它相關文章！