下列面試題都是在網上收集的，本人抱著學習的態度找了下參考答案，有不足的地方還請指正，更多精彩內容可以關註我的微信公眾號：Java團長 1、面向對象的特征有哪些方面？ 抽象：將同類對象的共同特征提取出來構造類。 繼承：基於基類創建新類。 封裝：將數據隱藏起來，對數據的訪問只能通過特定介面。 多態性：不 ...
下列面試題都是在網上收集的，本人抱著學習的態度找了下參考答案，有不足的地方還請指正，更多精彩內容可以關註我的微信公眾號：Java團長
1、面向對象的特征有哪些方面？
- 抽象：將同類對象的共同特征提取出來構造類。
- 繼承：基於基類創建新類。
- 封裝：將數據隱藏起來，對數據的訪問只能通過特定介面。
- 多態性：不同子類型對象對相同消息作出不同響應。
2、訪問修飾符public,private,protected,以及不寫（預設）時的區別？
protected 當前類，同包，異包子類。
3、String 是最基本的數據類型嗎？
答：不是。Java中的基本數據類型只有8個：byte、short、int、long、float、double、char、boolean；除了基本類型（primitive type），剩下的都是引用類型（reference type），Java 5以後引入的枚舉類型也算是一種比較特殊的引用類型。
4、float f=3.4;是否正確？
答:不正確。3.4是雙精度數，將雙精度型（double）賦值給浮點型（float）屬於下轉型（down-casting，也稱為窄化）會造成精度損失，因此需要強制類型轉換float f =(float)3.4; 或者寫成float f =3.4F;
5、short s1 = 1; s1 = s1 + 1;有錯嗎?short s1 = 1; s1 += 1;有錯嗎？
答：對於short s1 = 1; s1 = s1 + 1;由於1是int類型，因此s1+1運算結果也是int 型，需要強制轉換類型才能賦值給short型。而short s1 = 1; s1 += 1;可以正確編譯，因為s1+= 1;相當於s1 = (short)(s1 + 1);其中有隱含的強制類型轉換。
6、Java有沒有goto？
答：goto 是Java中的保留字，在目前版本的Java中沒有使用。（根據James Gosling（Java之父）編寫的《The Java Programming Language》一書的附錄中給出了一個Java關鍵字列表，其中有goto和const，但是這兩個是目前無法使用的關鍵字，因此有些地方將其稱之為保留字，其實保留字這個詞應該有更廣泛的意義，因為熟悉C語言的程式員都知道，在系統類庫中使用過的有特殊意義的單詞或單詞的組合都被視為保留字）
7、int和Integer有什麼區別？
答：Java是一個近乎純潔的面向對象編程語言，但是為了編程的方便還是引入了基本數據類型，但是為了能夠將這些基本數據類型當成對象操作，Java為每一個基本數據類型都引入了對應的包裝類型（wrapper class），int的包裝類就是Integer，從Java 5開始引入了自動裝箱/拆箱機制，使得二者可以相互轉換。
Java 為每個原始類型提供了包裝類型：
- 原始類型: boolean，char，byte，short，int，long，float，double
- 包裝類型：Boolean，Character，Byte，Short，Integer，Long，Float，Double
class AutoUnboxingTest {
public static void main(String[] args) {
Integer a = new Integer(3);
Integer b = 3; // 將3自動裝箱成Integer類型
int c = 3;
System.out.println(a == b); // false 兩個引用沒有引用同一對象
System.out.println(a == c); // true a自動拆箱成int類型再和c比較
}
}
最近還遇到一個面試題，也是和自動裝箱和拆箱有點關係的，代碼如下所示：
public class Test03 {
public static void main(String[] args) {
Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
System.out.println(f1 == f2);
System.out.println(f3 == f4);
}
}
如果不明就裡很容易認為兩個輸出要麼都是true要麼都是false。首先需要註意的是f1、f2、f3、f4四個變數都是Integer對象引用，所以下麵的==運算比較的不是值而是引用。裝箱的本質是什麼呢？當我們給一個Integer對象賦一個int值的時候，會調用Integer類的靜態方法valueOf，如果看看valueOf的源代碼就知道發生了什麼。
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
IntegerCache是Integer的內部類，其代碼如下所示：
/**
* Cache to support the object identity semantics of autoboxing for values between
* -128 and 127 (inclusive) as required by JLS.
*
* The cache is initialized on first usage. The size of the cache
* may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
* During VM initialization, java.lang.Integer.IntegerCache.high property
* may be set and saved in the private system properties in the
* sun.misc.VM class.
*/
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
簡單的說，如果整型字面量的值在-128到127之間，那麼不會new新的Integer對象，而是直接引用常量池中的Integer對象，所以上面的面試題中f1==f2的結果是true，而f3==f4的結果是false。
提醒：越是貌似簡單的面試題其中的玄機就越多，需要面試者有相當深厚的功力。
8、&和&&的區別？
答：&運算符有兩種用法：(1)按位與；(2)邏輯與。&&運算符是短路與運算。邏輯與跟短路與的差別是非常巨大的，雖然二者都要求運算符左右兩端的布爾值都是true整個表達式的值才是true。&&之所以稱為短路運算是因為，如果&&左邊的表達式的值是false，右邊的表達式會被直接短路掉，不會進行運算。很多時候我們可能都需要用&&而不是&，例如在驗證用戶登錄時判定用戶名不是null而且不是空字元串，應當寫為：username != null &&!username.equals("")，二者的順序不能交換，更不能用&運算符，因為第一個條件如果不成立，根本不能進行字元串的equals比較，否則會產生NullPointerException異常。註意：邏輯或運算符（|）和短路或運算符（||）的差別也是如此。
補充：如果你熟悉JavaScript，那你可能更能感受到短路運算的強大，想成為JavaScript的高手就先從玩轉短路運算開始吧。
9、解釋記憶體中的棧(stack)、堆(heap)和方法區(method area)的用法。
答：通常我們定義一個基本數據類型的變數，一個對象的引用，還有就是函數調用的現場保存都使用JVM中的棧空間；而通過new關鍵字和構造器創建的對象則放在堆空間，堆是垃圾收集器管理的主要區域，由於現在的垃圾收集器都採用分代收集演算法，所以堆空間還可以細分為新生代和老生代，再具體一點可以分為Eden、Survivor（又可分為From Survivor和To Survivor）、Tenured；方法區和堆都是各個線程共用的記憶體區域，用於存儲已經被JVM載入的類信息、常量、靜態變數、JIT編譯器編譯後的代碼等數據；程式中的字面量（literal）如直接書寫的100、"hello"和常量都是放在常量池中，常量池是方法區的一部分，。棧空間操作起來最快但是棧很小，通常大量的對象都是放在堆空間，棧和堆的大小都可以通過JVM的啟動參數來進行調整，棧空間用光了會引發StackOverflowError，而堆和常量池空間不足則會引發OutOfMemoryError。
String str = new String("hello");
上面的語句中變數str放在棧上，用new創建出來的字元串對象放在堆上，而"hello"這個字面量是放在方法區的。
補充1：較新版本的Java（從Java 6的某個更新開始）中，由於JIT編譯器的發展和"逃逸分析"技術的逐漸成熟，棧上分配、標量替換等優化技術使得對象一定分配在堆上這件事情已經變得不那麼絕對了。
補充2：運行時常量池相當於Class文件常量池具有動態性，Java語言並不要求常量一定只有編譯期間才能產生，運行期間也可以將新的常量放入池中，String類的intern()方法就是這樣的。
看看下麵代碼的執行結果是什麼並且比較一下Java 7以前和以後的運行結果是否一致。
String s1 = new StringBuilder("go")
.append("od").toString();
System.out.println(s1.intern() == s1);
String s2 = new StringBuilder("ja")
.append("va").toString();
System.out.println(s2.intern() == s2);
10、Math.round(11.5) 等於多少？Math.round(-11.5)等於多少？
答：Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四捨五入的原理是在參數上加0.5然後進行下取整。
11、switch 是否能作用在byte 上，是否能作用在long 上，是否能作用在String上？
答：在Java 5以前，switch(expr)中，expr只能是byte、short、char、int。從Java 5開始，Java中引入了枚舉類型，expr也可以是enum類型，從Java 7開始，expr還可以是字元串（String），但是長整型（long）在目前所有的版本中都是不可以的。
12、用最有效率的方法計算2乘以8？
答： 2 << 3（左移3位相當於乘以2的3次方，右移3位相當於除以2的3次方）。
補充：我們為編寫的類重寫hashCode方法時，可能會看到如下所示的代碼，其實我們不太理解為什麼要使用這樣的乘法運算來產生哈希碼（散列碼），而且為什麼這個數是個素數，為什麼通常選擇31這個數？前兩個問題的答案你可以自己百度一下，選擇31是因為可以用移位和減法運算來代替乘法，從而得到更好的性能。說到這裡你可能已經想到了：31 * num 等價於(num << 5) - num，左移5位相當於乘以2的5次方再減去自身就相當於乘以31，現在的VM都能自動完成這個優化。
public class PhoneNumber {
private int areaCode;
private String prefix;
private String lineNumber;
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + areaCode;
result = prime * result
+ ((lineNumber == null) ? 0 : lineNumber.hashCode());
result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
PhoneNumber other = (PhoneNumber) obj;
if (areaCode != other.areaCode)
return false;
if (lineNumber == null) {
if (other.lineNumber != null)
return false;
} else if (!lineNumber.equals(other.lineNumber))
return false;
if (prefix == null) {
if (other.prefix != null)
return false;
} else if (!prefix.equals(other.prefix))
return false;
return true;
}
}
13、數組有沒有length()方法？String有沒有length()方法？
答：數組沒有length()方法，有length 的屬性。String 有length()方法。JavaScript中，獲得字元串的長度是通過length屬性得到的，這一點容易和Java混淆。
14、在Java中，如何跳出當前的多重嵌套迴圈？
答：在最外層迴圈前加一個標記如A，然後用break A;可以跳出多重迴圈。（Java中支持帶標簽的break和continue語句，作用有點類似於C和C++中的goto語句，但是就像要避免使用goto一樣，應該避免使用帶標簽的break和continue，因為它不會讓你的程式變得更優雅，很多時候甚至有相反的作用，所以這種語法其實不知道更好）
15、構造器（constructor）是否可被重寫（override）？
答：構造器不能被繼承，因此不能被重寫，但可以被重載。
16、兩個對象值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對？
答：不對，如果兩個對象x和y滿足x.equals(y) == true，它們的哈希碼（hash code）應當相同。Java對於eqauls方法和hashCode方法是這樣規定的：(1)如果兩個對象相同（equals方法返回true），那麼它們的hashCode值一定要相同；(2)如果兩個對象的hashCode相同，它們並不一定相同。當然，你未必要按照要求去做，但是如果你違背了上述原則就會發現在使用容器時，相同的對象可以出現在Set集合中，同時增加新元素的效率會大大下降（對於使用哈希存儲的系統，如果哈希碼頻繁的衝突將會造成存取性能急劇下降）。
補充：關於equals和hashCode方法，很多Java程式都知道，但很多人也就是僅僅知道而已，在Joshua Bloch的大作《Effective Java》（很多軟體公司，《Effective Java》、《Java編程思想》以及《重構：改善既有代碼質量》是Java程式員必看書籍，如果你還沒看過，那就趕緊去亞馬遜買一本吧）中是這樣介紹equals方法的：首先equals方法必須滿足自反性（x.equals(x)必須返回true）、對稱性（x.equals(y)返回true時，y.equals(x)也必須返回true）、傳遞性（x.equals(y)和y.equals(z)都返回true時，x.equals(z)也必須返回true）和一致性（當x和y引用的對象信息沒有被修改時，多次調用x.equals(y)應該得到同樣的返回值），而且對於任何非null值的引用x，x.equals(null)必須返回false。實現高質量的equals方法的訣竅包括：1. 使用==操作符檢查"參數是否為這個對象的引用"；2. 使用instanceof操作符檢查"參數是否為正確的類型"；3. 對於類中的關鍵屬性，檢查參數傳入對象的屬性是否與之相匹配；4. 編寫完equals方法後，問自己它是否滿足對稱性、傳遞性、一致性；5. 重寫equals時總是要重寫hashCode；6. 不要將equals方法參數中的Object對象替換為其他的類型，在重寫時不要忘掉@Override註解。
17、是否可以繼承String類？
答：String 類是final類，不可以被繼承。
補充：繼承String本身就是一個錯誤的行為，對String類型最好的重用方式是關聯關係（Has-A）和依賴關係（Use-A）而不是繼承關係（Is-A）。
18、當一個對象被當作參數傳遞到一個方法後，此方法可改變這個對象的屬性，並可返回變化後的結果，那麼這裡到底是按值傳遞還是按引用傳遞？
答：是按值傳遞。Java語言的方法調用只支持參數的按值傳遞。當一個對象實例作為一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的屬性可以在被調用過程中被改變，但在方法內部對對象引用的改變是不會影響到被調用者的。C++和C#中可以通過傳引用或傳輸出參數來改變傳入的參數的值。在C#中可以編寫如下所示的代碼，但是在Java中卻做不到。
using System;
namespace CS01 {
class Program {
public static void swap(ref int x, ref int y) {
int temp = x;
x = y;
y = temp;
}
public static void Main (string[] args) {
int a = 5, b = 10;
swap (ref a, ref b);
// a = 10, b = 5;
Console.WriteLine ("a = {0}, b = {1}", a, b);
}
}
}
說明：Java中沒有傳引用實在是非常的不方便，這一點在Java 8中仍然沒有得到改進，正是如此在Java編寫的代碼中才會出現大量的Wrapper類（將需要通過方法調用修改的引用置於一個Wrapper類中，再將Wrapper對象傳入方法），這樣的做法只會讓代碼變得臃腫，尤其是讓從C和C++轉型為Java程式員的開發者無法容忍。
19、String和StringBuilder、StringBuffer的區別？
答：Java平臺提供了兩種類型的字元串：String和StringBuffer/StringBuilder，它們可以儲存和操作字元串。其中String是只讀字元串，也就意味著String引用的字元串內容是不能被改變的。而StringBuffer/StringBuilder類表示的字元串對象可以直接進行修改。StringBuilder是Java 5中引入的，它和StringBuffer的方法完全相同，區別在於它是在單線程環境下使用的，因為它的所有方面都沒有被synchronized修飾，因此它的效率也比StringBuffer要高。
面試題1 - 什麼情況下用+運算符進行字元串連接比調用StringBuffer/StringBuilder對象的append方法連接字元串性能更好？
面試題2 - 請說出下麵程式的輸出。
class StringEqualTest {
public static void main(String[] args) {
String s1 = "Programming";
String s2 = new String("Programming");
String s3 = "Program";
String s4 = "ming";
String s5 = "Program" + "ming";
String s6 = s3 + s4;
System.out.println(s1 == s2);
System.out.println(s1 == s5);
System.out.println(s1 == s6);
System.out.println(s1 == s6.intern());
System.out.println(s2 == s2.intern());
}
}
補充：解答上面的面試題需要清除兩點：1. String對象的intern方法會得到字元串對象在常量池中對應的版本的引用（如果常量池中有一個字元串與String對象的equals結果是true），如果常量池中沒有對應的字元串，則該字元串將被添加到常量池中，然後返回常量池中字元串的引用；2. 字元串的+操作其本質是創建了StringBuilder對象進行append操作，然後將拼接後的StringBuilder對象用toString方法處理成String對象，這一點可以用javap -c StringEqualTest.class命令獲得class文件對應的JVM位元組碼指令就可以看出來。
20、重載（Overload）和重寫（Override）的區別。重載的方法能否根據返回類型進行區分？
答：方法的重載和重寫都是實現多態的方式，區別在於前者實現的是編譯時的多態性，而後者實現的是運行時的多態性。重載發生在一個類中，同名的方法如果有不同的參數列表（參數類型不同、參數個數不同或者二者都不同）則視為重載；重寫發生在子類與父類之間，重寫要求子類被重寫方法與父類被重寫方法有相同的返回類型，比父類被重寫方法更好訪問，不能比父類被重寫方法聲明更多的異常（里氏代換原則）。重載對返回類型沒有特殊的要求。
面試題：華為的面試題中曾經問過這樣一個問題 - "為什麼不能根據返回類型來區分重載"，快說出你的答案吧！
因為調用時不能指定類型信息，編譯器不知道你要調用哪個函數。
例如：
float max(int a, int b);
int max(int a, int b);
當調用max(1, 2);時無法確定調用的是哪個，單從這一點上來說，僅返回值類型不同的重載是不應該允許的。
21、描述一下JVM載入class文件的原理機制？
答：JVM中類的裝載是由類載入器（ClassLoader）和它的子類來實現的，Java中的類載入器是一個重要的Java運行時系統組件，它負責在運行時查找和裝入類文件中的類。
由於Java的跨平臺性，經過編譯的Java源程式並不是一個可執行程式，而是一個或多個類文件。當Java程式需要使用某個類時，JVM會確保這個類已經被載入、連接（驗證、準備和解析）和初始化。類的載入是指把類的.class文件中的數據讀入到記憶體中，通常是創建一個位元組數組讀入.class文件，然後產生與所載入類對應的Class對象。載入完成後，Class對象還不完整，所以此時的類還不可用。當類被載入後就進入連接階段，這一階段包括驗證、準備（為靜態變數分配記憶體並設置預設的初始值）和解析（將符號引用替換為直接引用）三個步驟。最後JVM對類進行初始化，包括：1)如果類存在直接的父類並且這個類還沒有被初始化，那麼就先初始化父類；2)如果類中存在初始化語句，就依次執行這些初始化語句。
類的載入是由類載入器完成的，類載入器包括：根載入器（BootStrap）、擴展載入器（Extension）、系統載入器（System）和用戶自定義類載入器（java.lang.ClassLoader的子類）。從Java 2（JDK 1.2）開始，類載入過程採取了父親委托機制（PDM）。PDM更好的保證了Java平臺的安全性，在該機制中，JVM自帶的Bootstrap是根載入器，其他的載入器都有且僅有一個父類載入器。類的載入首先請求父類載入器載入，父類載入器無能為力時才由其子類載入器自行載入。JVM不會向Java程式提供對Bootstrap的引用。下麵是關於幾個類載入器的說明：
- Bootstrap：一般用本地代碼實現，負責載入JVM基礎核心類庫（rt.jar）；
- Extension：從java.ext.dirs系統屬性所指定的目錄中載入類庫，它的父載入器是Bootstrap；
- System：又叫應用類載入器，其父類是Extension。它是應用最廣泛的類載入器。它從環境變數classpath或者系統屬性java.class.path所指定的目錄中載入類，是用戶自定義載入器的預設父載入器。
22、char 型變數中能不能存貯一個中文漢字，為什麼？
答：char類型可以存儲一個中文漢字，因為Java中使用的編碼是Unicode（不選擇任何特定的編碼，直接使用字元在字元集中的編號，這是統一的唯一方法），一個char類型占2個位元組（16比特），所以放一個中文是沒問題的。
補充：使用Unicode意味著字元在JVM內部和外部有不同的表現形式，在JVM內部都是Unicode，當這個字元被從JVM內部轉移到外部時（例如存入文件系統中），需要進行編碼轉換。所以Java中有位元組流和字元流，以及在字元流和位元組流之間進行轉換的轉換流，如InputStreamReader和OutputStreamReader，這兩個類是位元組流和字元流之間的適配器類，承擔了編碼轉換的任務；對於C程式員來說，要完成這樣的編碼轉換恐怕要依賴於union（聯合體/共用體）共用記憶體的特征來實現了。
23、抽象類（abstract class）和介面（interface）有什麼異同？
答：抽象類和介面都不能夠實例化，但可以定義抽象類和介面類型的引用。一個類如果繼承了某個抽象類或者實現了某個介面都需要對其中的抽象方法全部進行實現，否則該類仍然需要被聲明為抽象類。介面比抽象類更加抽象，因為抽象類中可以定義構造器，可以有抽象方法和具體方法，而介面中不能定義構造器而且其中的方法全部都是抽象方法。抽象類中的成員可以是private、預設、protected、public的，而介面中的成員全都是public的。抽象類中可以定義成員變數，而介面中定義的成員變數實際上都是常量。有抽象方法的類必須被聲明為抽象類，而抽象類未必要有抽象方法。
24、靜態嵌套類(Static Nested Class)和內部類（Inner Class）的不同？
答：Static Nested Class是被聲明為靜態（static）的內部類，它可以不依賴於外部類實例被實例化。而通常的內部類需要在外部類實例化後才能實例化，其語法看起來挺詭異的，如下所示。
/**
* 撲克類（一副撲克）
*
*/
public class Poker {
private static String[] suites = {"黑桃", "紅桃", "草花", "方塊"};
private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
private Card[] cards;
/**
* 構造器
*
*/
public Poker() {
cards = new Card[52];
for(int i = 0; i < suites.length; i++) {
for(int j = 0; j < faces.length; j++) {
cards[i * 13 + j] = new Card(suites[i], faces[j]);
}
}
}
/**
* 洗牌 （隨機亂序）
*
*/
public void shuffle() {
for(int i = 0, len = cards.length; i < len; i++) {
int index = (int) (Math.random() * len);
Card temp = cards[index];
cards[index] = cards[i];
cards[i] = temp;
}
}
/**
* 發牌
* @param index 發牌的位置
*
*/
public Card deal(int index) {
return cards[index];
}
/**
* 卡片類（一張撲克）
* [內部類]
*
*/
public class Card {
private String suite; // 花色
private int face; // 點數
public Card(String suite, int face) {
this.suite = suite;
this.face = face;
}
@Override
public String toString() {
String faceStr = "";
switch(face) {
case 1: faceStr = "A"; break;
case 11: faceStr = "J"; break;
case 12: faceStr = "Q"; break;
case 13: faceStr = "K"; break;
default: faceStr = String.valueOf(face);
}
return suite + faceStr;
}
}
}
測試代碼：
class PokerTest {
public static void main(String[] args) {
Poker poker = new Poker();
poker.shuffle(); // 洗牌
Poker.Card c1 = poker.deal(0); // 發第一張牌
// 對於非靜態內部類Card
// 只有通過其外部類Poker對象才能創建Card對象
Poker.Card c2 = poker.new Card("紅心", 1); // 自己創建一張牌
System.out.println(c1); // 洗牌後的第一張
System.out.println(c2); // 列印: 紅心A
}
}
面試題 - 下麵的代碼哪些地方會產生編譯錯誤？
class Outer {
class Inner {}
public static void foo() { new Inner(); }
public void bar() { new Inner(); }
public static void main(String[] args) {
new Inner();
}
}
註意：Java中非靜態內部類對象的創建要依賴其外部類對象，上面的面試題中foo和main方法都是靜態方法，靜態方法中沒有this，也就是說沒有所謂的外部類對象，因此無法創建內部類對象，如果要在靜態方法中創建內部類對象，可以這樣做：
new Outer().new Inner();
25、Java 中會存在記憶體泄漏嗎，請簡單描述。
答：理論上Java因為有垃圾回收機制（GC）不會存在記憶體泄露問題（這也是Java被廣泛使用於伺服器端編程的一個重要原因）；然而在實際開發中，可能會存在無用但可達的對象，這些對象不能被GC回收，因此也會導致記憶體泄露的發生。例如Hibernate的Session（一級緩存）中的對象屬於持久態，垃圾回收器是不會回收這些對象的，然而這些對象中可能存在無用的垃圾對象，如果不及時關閉（close）或清空（flush）一級緩存就可能導致記憶體泄露。下麵例子中的代碼也會導致記憶體泄露。
import java.util.Arrays;
import java.util.EmptyStackException;
public class MyStack<T> {
private T[] elements;
private int size = 0;
private static final int INIT_CAPACITY = 16;
