溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
小編給大家分享一下Java初始化與清理的案例分析，希望大家閱讀完這篇文章后大所收獲，下面讓我們一起去探討吧！
大家都知道，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初始化與清理的案例分析有了一定的了解，想了解更多相關知識，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
