詳解Java的初始化與清理

更新時間：2020年07月10日 08:34:38 作者：蒼穹2018

這篇文章主要介紹了Java的初始化與清理，文中示例代碼非常詳細，幫助大家更好的理解和學習，感興趣的朋友可以了解下

　　大家都知道，Java是站在巨人的肩上成功的，它是在C&C++的基礎(chǔ)上進一步的開發(fā)，投入面向?qū)ο箝_發(fā)的懷抱。Java吸取了很多以前的教訓，加入自己很多獨創(chuàng)的方式。在程序語言發(fā)展初期，許多C程序員經(jīng)常忘記初始化變量，在程序結(jié)束后也經(jīng)常忘記對創(chuàng)建的數(shù)據(jù)類型進行釋放內(nèi)存，造成內(nèi)存泄漏。這些"不安全"的編程方式當然需要程序員有良好的編程習慣，但如果編程語言能夠加入自動清理與初始化的工作，這回大大降低開發(fā)成本。隨著技術(shù)的發(fā)展，C++語言引入了構(gòu)造器（constructor），即在創(chuàng)建對象自動調(diào)用的初識方法，Java語言采用這一方法，并加入垃圾回收器，負責自動回收用戶創(chuàng)建的內(nèi)存，進一步降低程序員的開發(fā)成本。

Java的初始化與構(gòu)造器

　　創(chuàng)建Java的對象最普遍發(fā)的方法是使用new方法，如下所示。而創(chuàng)建對象必須使用構(gòu)造器，構(gòu)造器實際就是Java對象初始化的方法，用戶可以在該方法中添加自定義初始化行為。

 Object obj = new Object(); // 左側(cè)為聲明對象，右側(cè)為實際創(chuàng)建一個對象

　　構(gòu)造器它是一個隱含為靜態(tài)的無返回值的方法，名稱與類名相同，編譯期會自動調(diào)用該方法。如果用戶沒有創(chuàng)建構(gòu)造器，編譯期會為你自動生成一個默認構(gòu)造器。總之，構(gòu)造器個數(shù)至少有一個。構(gòu)造器可以有多個，它可以用戶自己選擇如何初始化對象，這里是使用重載（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初始化，那肯定要關(guān)注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關(guān)鍵字可知該類有個父類，于是加載該父類，如果該父類還有它自身的父類，繼續(xù)加載，然后執(zhí)行最高一層類的static初始化，然后是其子類，依次執(zhí)行，最后所有的類的已加載完成，開始執(zhí)行main方法：在main方法中開始創(chuàng)建對象，對象被創(chuàng)建之后，虛擬機會為其分配內(nèi)存，主要用來存放對象的實例變量及其從父類繼承過來的實例變量(即使這些從父類繼承過來的實例變量有可能被隱藏也會被分配空間)。在為這些實例變量分配內(nèi)存的同時，這些實例變量也會被賦予默認值。在內(nèi)存中創(chuàng)建對象后，開始調(diào)用父類的構(gòu)造器，父類的構(gòu)造器能夠使用super調(diào)用或被編譯期自動調(diào)用，父類在執(zhí)行構(gòu)造器語句之前，會對父類實例變量按照次序進行初始化。父類完成父類子對象的初始化后，子類開始的順序執(zhí)行，先實例變量初始化，然后執(zhí)行構(gòu)造器語句。最后整個對象構(gòu)造完成。

Java的對象與清理

　　Java的顯著優(yōu)點就是Java有良好的垃圾清理機制，C++中創(chuàng)建對象，使用對象后，需要使用delete操作符刪除對象，就會調(diào)用對應的析構(gòu)函數(shù)。而Java中沒有析構(gòu)函數(shù)，Java的finalize()并不是類似C++的析構(gòu)函數(shù)，Java的finalize()只是用來回收本地方法（c/c++）占用的內(nèi)存（調(diào)用本地方法類似free）。通常意義上來講，Java程序員只需創(chuàng)建對象，而不需我們自己去銷毀對象，因為垃圾回收機制會幫我們回收對象，雖然不知道什么時候回收，是否會被回收。

　　然后可能會出現(xiàn)這種情況，類可能要在生命周期內(nèi)執(zhí)行一些必需的清理活動，這就需要程序員自己書寫清理方法，在清理方法中必須注意清理順序，即其順序與初始化順序相反，為防止出現(xiàn)異常，可以將清理動作放入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*/