大家都應該知道Java是目前最火的計算機語言之一，連續幾年蟬聯最受程式設計師歡迎的計算機語言榜首，因此每年新入職Java程式設計師也數不勝數。究竟這些新入職的Java程式設計師是入坑還是入行呢?那就要看他們對於Java這門語言的看法了。不管如何，在入職之前，問題會要經過面試，那麼Java面試題是怎麼出的呢?下面羅列了20道常見初級Java面試題，簡直是入職者必備!
　　
　　1、面向物件的特徵有哪些方面?
　　答：面向物件的特徵主要有以下幾個方面：
　　- 抽象：抽象是將一類物件的共同特徵總結出來構造類的過程，包括資料抽象和行為抽象兩方面。抽象只關注物件有哪些屬性和行為，並不關注這些行為的細節是什麼。
　　- 繼承：繼承是從已有類得到繼承資訊建立新類的過程。提供繼承資訊的類被稱為父類(超類、基類);得到繼承資訊的類被稱為子類(派生類)。繼承讓變化中的軟體系統有了一定的延續性，同時繼承也是封裝程式中可變因素的重要手段(如果不能理解請閱讀閻巨集博士的《Java與模式》或《設計模式精解》中關於橋樑模式的部分)。
　　- 封裝：通常認為封裝是把資料和操作資料的方法繫結起來，對資料的訪問只能通過已定義的介面。面向物件的本質就是將現實世界描繪成一系列完全自治、封閉的物件。我們在類中編寫的方法就是對實現細節的一種封裝;我們編寫一個類就是對資料和資料操作的封裝。可以說，封裝就是隱藏一切可隱藏的東西，只向外界提供最簡單的程式設計介面(可以想想普通洗衣機和全自動洗衣機的差別，明顯全自動洗衣機封裝更好因此操作起來更簡單;我們現在使用的智慧手機也是封裝得足夠好的，因為幾個按鍵就搞定了所有的事情)。
　　- 多型性：多型性是指允許不同子型別的物件對同一訊息作出不同的響應。簡單的說就是用同樣的物件引用呼叫同樣的方法但是做了不同的事情。多型性分為編譯時的多型性和執行時的多型性。如果將物件的方法視為物件向外界提供的服務，那麼執行時的多型性可以解釋為：當A系統訪問B系統提供的服務時，B系統有多種提供服務的方式，但一切對A系統來說都是透明的(就像電動剃鬚刀是A系統，它的供電系統是B系統，B系統可以使用電池供電或者用交流電，甚至還有可能是太陽能，A系統只會通過B類物件呼叫供電的方法，但並不知道供電系統的底層實現是什麼，究竟通過何種方式獲得了動力)。方法過載(overload)實現的是編譯時的多型性(也稱為前繫結)，而方法重寫(override)實現的是執行時的多型性(也稱為後繫結)。執行時的多型是面向物件最精髓的東西，要實現多型需要做兩件事：1). 方法重寫(子類繼承父類並重寫父類中已有的或抽象的方法);2). 物件造型(用父型別引用引用子型別物件，這樣同樣的引用呼叫同樣的方法就會根據子類物件的不同而表現出不同的行為)。
　　2、訪問修飾符public,private,protected,以及不寫(預設)時的區別?

　　答：

修飾符   當前類   同 包  子 類    其他包
public     √    √      √    √
protected  √    √      √    ×
default    √    √      ×     ×
private    √    ×       ×     ×

　　類的成員不寫訪問修飾時預設為default。預設對於同一個包中的其他類相當於公開(public)，對於不是同一個包中的其他類相當於私有(private)。受保護(protected)對子類相當於公開，對不是同一包中的沒有父子關係的類相當於私有。Java中，外部類的修飾符只能是public或預設，類的成員(包括內部類)的修飾符可以是以上四種。
　　3、String 是最基本的資料型別嗎?

　　答：不是。Java中的基本資料型別只有8個：byte、short、int、long、float、double、char、boolean;除了基本型別(primitive type)和列舉型別(enumeration type)，剩下的都是引用型別(reference type)。
　　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=} 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、解釋記憶體中的棧(stack)、堆(heap)和靜態區(static area)的用法。
　　答：通常我們定義一個基本資料型別的變數，一個物件的引用，還有就是函式呼叫的現場儲存都使用記憶體中的棧空間;而通過new關鍵字和構造器建立的物件放在堆空間;程式中的字面量(literal)如直接書寫的100、”hello”和常量都是放在靜態區中。棧空間操作起來最快但是棧很小，通常大量的物件都是放在堆空間，理論上整個記憶體沒有被其他程序使用的空間甚至硬碟上的虛擬記憶體都可以被當成堆空間來使用。
　　

String str = new String("hello");

　　上面的語句中變數str放在棧上，用new創建出來的字串物件放在堆上，而”hello”這個字面量放在靜態區。
　　9、當一個物件被當作引數傳遞到一個方法後，此方法可改變這個物件的屬性，並可返回變化後的結果，那麼這裡到底是值傳遞還是引用傳遞?
　　答：是值傳遞。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程式設計師的開發者無法容忍。
　　10、過載(Overload)和重寫(Override)的區別。過載的方法能否根據返回型別進行區分?
　　答：方法的過載和重寫都是實現多型的方式，區別在於前者實現的是編譯時的多型性，而後者實現的是執行時的多型性。過載發生在一個類中，同名的方法如果有不同的引數列表(引數型別不同、引數個數不同或者二者都不同)則視為過載;重寫發生在子類與父類之間，重寫要求子類被重寫方法與父類被重寫方法有相同的返回型別，比父類被重寫方法更好訪問，不能比父類被重寫方法宣告更多的異常(里氏代換原則)。過載對返回型別沒有特殊的要求。
　　面試題：華為的面試題中曾經問過這樣一個問題 - “為什麼不能根據返回型別來區分過載”，快說出你的答案吧!
　　11、描述一下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所指定的目錄中記載類，是使用者自定義載入器的預設父載入器。
　　12、抽象類(abstract class)和介面(interface)有什麼異同?
　　答：抽象類和介面都不能夠例項化，但可以定義抽象類和介面型別的引用。一個類如果繼承了某個抽象類或者實現了某個介面都需要對其中的抽象方法全部進行實現，否則該類仍然需要被宣告為抽象類。介面比抽象類更加抽象，因為抽象類中可以定義構造器，可以有抽象方法和具體方法，而介面中不能定義構造器而且其中的方法全部都是抽象方法。抽象類中的成員可以是private、預設、protected、public的，而介面中的成員全都是public的。抽象類中可以定義成員變數，而介面中定義的成員變數實際上都是常量。有抽象方法的類必須被宣告為抽象類，而抽象類未必要有抽象方法。
　　13、靜態巢狀類(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();

　　14、Java 中會存在記憶體洩漏嗎，請簡單描述。
　　答：理論上Java因為有垃圾回收機制(GC)不會存在記憶體洩露問題(這也是Java被廣泛使用於伺服器端程式設計的一個重要原因);然而在實際開發中，可能會存在無用但可達的物件，這些物件不能被GC回收，因此也會導致記憶體洩露的發生。例如Hibernate的Session(一級快取)中的物件屬於持久態，垃圾回收器是不會回收這些物件的，然而這些物件中可能存在無用的垃圾物件，如果不及時關閉(close)或清空(flush)一級快取就可能導致記憶體洩露。下面例子中的程式碼也會導致記憶體洩露。
　　

import java.util.Arrays;
　　import java.util.EmptyStackException;
　　public class MyStack {
　　private T[] elements;
　　private int size = 0;
　　private static final int INIT_CAPACITY = 16;
　　public MyStack() {
　　elements = (T[]) new Object[INIT_CAPACITY];
　　}
　　public void push(T elem) {
　　ensureCapacity();
　　elements[size++] = elem;
　　}
　　public T pop() {
　　if(size == 0)
　　throw new EmptyStackException();
　　return elements[--size];
　　}
　　private void ensureCapacity() {
　　if(elements.length == size) {
　　elements = Arrays.copyOf(elements, 2 * size + 1);
　　}
　　}
　　}

　　上面的程式碼實現了一個棧(先進後出(FILO))結構，乍看之下似乎沒有什麼明顯的問題，它甚至可以通過你編寫的各種單元測試。然而其中的pop方法卻存在記憶體洩露的問題，當我們用pop方法彈出棧中的物件時，該物件不會被當作垃圾回收，即使使用棧的程式不再引用這些物件，因為棧內部維護著對這些物件的過期引用(obsolete reference)。在支援垃圾回收的語言中，記憶體洩露是很隱蔽的，這種記憶體洩露其實就是無意識的物件保持。如果一個物件引用被無意識的保留起來了，那麼垃圾回收器不會處理這個物件，也不會處理該物件引用的其他物件，即使這樣的物件只有少數幾個，也可能會導致很多的物件被排除在垃圾回收之外，從而對效能造成重大影響，極端情況下會引發Disk Paging(實體記憶體與硬碟的虛擬記憶體交換資料)，甚至造成OutOfMemoryError。
　　15、如何實現物件克隆?
　　答：有兩種方式：
　　1). 實現Cloneable介面並重寫Object類中的clone()方法;
　　2). 實現Serializable介面，通過物件的序列化和反序列化實現克隆，可以實現真正的深度克隆，程式碼如下。
　　

import java.io.ByteArrayInputStream;
　　import java.io.ByteArrayOutputStream;
　　import java.io.ObjectInputStream;
　　import java.io.ObjectOutputStream;
　　public class MyUtil {
　　private MyUtil() {
　　throw new Asserti();
　　}
　　public static T clone(T obj) throws Exception {
　　ByteArrayOutputStream bout = new ByteArrayOutputStream();
　　ObjectOutputStream oos = new ObjectOutputStream(bout);
　　oos.writeObject(obj);
　　ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
　　ObjectInputStream ois = new ObjectInputStream(bin);
　　return (T) ois.readObject();
　　// 說明：呼叫ByteArrayInputStream或ByteArrayOutputStream物件的close方法沒有任何意義
　　// 這兩個基於記憶體的流只要垃圾回收器清理物件就能夠釋放資源，這一點不同於對外部資源(如檔案流)的釋放
　　}
　　}

　　下面是測試程式碼：
　　

import java.io.Serializable;
　　/**
　　* 人類
　　*/
　　class Person implements Serializable {
　　private static final long serialVersionUID = -9102017020286042305L;
　　private String name; // 姓名
　　private int age; // 年齡
　　private Car car; // 座駕
　　public Person(String name, int age, Car car) {
　　this.name = name;
　　this.age = age;
　　this.car = car;
　　}
　　public String getName() {
　　return name;
　　}
　　public void setName(String name) {
　　this.name = name;
　　}
　　public int getAge() {
　　return age;
　　}
　　public void setAge(int age) {
　　this.age = age;
　　}
　　public Car getCar() {
　　return car;
　　}
　　public void setCar(Car car) {
　　this.car = car;
　　}
　　@Override
　　public String toString() {
　　return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
　　}
　　}1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950
　　/**
　　* 小汽車類
　　*/
　　class Car implements Serializable {
　　private static final long serialVersionUID = -5713945027627603702L;
　　private String brand; // 品牌
　　private int maxSpeed; // 最高時速
　　public Car(String brand, int maxSpeed) {
　　this.brand = brand;
　　this.maxSpeed = maxSpeed;
　　}
　　public String getBrand() {
　　return brand;
　　}
　　public void setBrand(String brand) {
　　this.brand = brand;
　　}
　　public int getMaxSpeed() {
　　return maxSpeed;
　　}
　　public void setMaxSpeed(int maxSpeed) {
　　this.maxSpeed = maxSpeed;
　　}
　　@Override
　　public String toString() {
　　return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
　　}
　　}
　　class CloneTest {
　　public static void main(String[] args) {
　　try {
　　Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300));
　　Person p2 = MyUtil.clone(p1); // 深度克隆
　　p2.getCar().setBrand("BYD");
　　// 修改克隆的Person物件p2關聯的汽車物件的品牌屬性
　　// 原來的Person物件p1關聯的汽車不會受到任何影響
　　// 因為在克隆Person物件時其關聯的汽車物件也被克隆了
　　System.out.println(p1);
　　} catch (Exception e) {
　　e.printStackTrace();
　　}
　　}
　　}

　　注意：基於序列化和反序列化實現的克隆不僅僅是深度克隆，更重要的是通過泛型限定，可以檢查出要克隆的物件是否支援序列化，這項檢查是編譯器完成的，不是在執行時丟擲異常，這種是方案明顯優於使用Object類的clone方法克隆物件。讓問題在編譯的時候暴露出來總是優於把問題留到執行時。
　　16、GC是什麼?為什麼要有GC?
　　答：GC是垃圾收集的意思，記憶體處理是程式設計人員容易出現問題的地方，忘記或者錯誤的記憶體回收會導致程式或系統的不穩定甚至崩潰，Java提供的GC功能可以自動監測物件是否超過作用域從而達到自動回收記憶體的目的，Java語言沒有提供釋放已分配記憶體的顯示操作方法。Java程式設計師不用擔心記憶體管理，因為垃圾收集器會自動進行管理。要請求垃圾收集，可以呼叫下面的方法之一：System.gc() 或Runtime.getRuntime().gc() ，但JVM可以遮蔽掉顯示的垃圾回收呼叫。
　　垃圾回收可以有效的防止記憶體洩露，有效的使用可以使用的記憶體。垃圾回收器通常是作為一個單獨的低優先順序的執行緒執行，不可預知的情況下對記憶體堆中已經死亡的或者長時間沒有使用的物件進行清除和回收，程式設計師不能實時的呼叫垃圾回收器對某個物件或所有物件進行垃圾回收。在Java誕生初期，垃圾回收是Java最大的亮點之一，因為伺服器端的程式設計需要有效的防止記憶體洩露問題，然而時過境遷，如今Java的垃圾回收機制已經成為被詬病的東西。移動智慧終端使用者通常覺得iOS的系統比Android系統有更好的使用者體驗，其中一個深層次的原因就在於Android系統中垃圾回收的不可預知性。
　　補充：垃圾回收機制有很多種，包括：分代複製垃圾回收、標記垃圾回收、增量垃圾回收等方式。標準的Java程序既有棧又有堆。棧儲存了原始型區域性變數，堆儲存了要建立的物件。Java平臺對堆記憶體回收和再利用的基本演算法被稱為標記和清除，但是Java對其進行了改進，採用“分代式垃圾收集”。這種方法會跟Java物件的生命週期將堆記憶體劃分為不同的區域，在垃圾收集過程中，可能會將物件移動到不同區域：
　　- 伊甸園(Eden)：這是物件最初誕生的區域，並且對大多數物件來說，這裡是它們唯一存在過的區域。
　　- 倖存者樂園(Survivor)：從伊甸園倖存下來的物件會被挪到這裡。
　　- 終身頤養園(Tenured)：這是足夠老的倖存物件的歸宿。年輕代收集(Minor-GC)過程是不會觸及這個地方的。當年輕代收集不能把物件放進終身頤養園時，就會觸發一次完全收集(Major-GC)，這裡可能還會牽扯到壓縮，以便為大物件騰出足夠的空間。
　　與垃圾回收相關的JVM引數：
　　-Xms / -Xmx — 堆的初始大小 / 堆的最大大小
　　-Xmn — 堆中年輕代的大小
　　-XX:-DisableExplicitGC — 讓System.gc()不產生任何作用
　　-XX:+PrintGCDetails — 列印GC的細節
　　-XX:+PrintGCDateStamps — 列印GC操作的時間戳
　　-XX:NewSize / XX:MaxNewSize — 設定新生代大小/新生代最大大小
　　-XX:NewRatio — 可以設定老生代和新生代的比例
　　-XX:PrintTenuringDistribution — 設定每次新生代GC後輸出倖存者樂園中物件年齡的分佈
　　-XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold：設定老年代閥值的初始值和最大值
　　-XX:TargetSurvivorRatio：設定倖存區的目標使用率
　　17、日期和時間：
　　- 如何取得年月日、小時分鐘秒?
　　- 如何取得從1970年1月1日0時0分0秒到現在的毫秒數?
　　- 如何取得某月的最後一天?
　　- 如何格式化日期?
　　答：
　　問題1：建立java.util.Calendar 例項，呼叫其get()方法傳入不同的引數即可獲得引數所對應的值。Java 8中可以使用java.time.LocalDateTimel來獲取，程式碼如下所示。
　　

public class DateTimeTest {
　　public static void main(String[] args) {
　　Calendar cal = Calendar.getInstance();
　　System.out.println(cal.get(Calendar.YEAR));
　　System.out.println(cal.get(Calendar.MONTH)); // 0 - 11
　　System.out.println(cal.get(Calendar.DATE));
　　System.out.println(cal.get(Calendar.HOUR_OF_DAY));
　　System.out.println(cal.get(Calendar.MINUTE));
　　System.out.println(cal.get(Calendar.SECOND));
　　// Java 8
　　LocalDateTime dt = LocalDateTime.now();
　　System.out.println(dt.getYear());
　　System.out.println(dt.getMonthValue()); // 1 - 12
　　System.out.println(dt.getDayOfMonth());
　　System.out.println(dt.getHour());
　　System.out.println(dt.getMinute());
　　System.out.println(dt.getSecond());
　　}
　　}

　　問題2：以下方法均可獲得該毫秒數。
　　

   Calendar.getInstance().getTimeInMillis();
　　System.currentTimeMillis();
　　Clock.systemDefaultZone().millis(); // Java 8

　　問題3：程式碼如下所示。
　　

   Calendar time = Calendar.getInstance();
　　time.getActualMaximum(Calendar.DAY_OF_MONTH);12

　　問題4：利用java.text.DataFormat 的子類(如SimpleDateFormat類)中的format(Date)方法可將日期格式化。Java 8中可以用java.time.format.DateTimeFormatter來格式化時間日期，程式碼如下所示。
　　

import java.text.SimpleDateFormat;
　　import java.time.LocalDate;
　　import java.time.format.DateTimeFormatter;
　　import java.util.Date;
　　class DateFormatTest {
　　public static void main(String[] args) {
　　SimpleDateFormat oldFormatter = new SimpleDateFormat("yyyy/MM/dd");
　　Date date1 = new Date();
　　System.out.println(oldFormatter.format(date1));
　　// Java 8
　　DateTimeFormatter newFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
　　LocalDate date2 = LocalDate.now();
　　System.out.println(date2.format(newFormatter));
　　}
　　}

　　補充：Java的時間日期API一直以來都是被詬病的東西，為了解決這一問題，Java 8中引入了新的時間日期API，其中包括LocalDate、LocalTime、LocalDateTime、Clock、Instant等類，這些的類的設計都使用了不變模式，因此是執行緒安全的設計。如果不理解這些內容，可以參考我的另一篇文章《關於Java併發程式設計的總結和思考》。
　　18、比較一下Java和JavaSciprt。
　　答：Java 與Java是兩個公司開發的不同的兩個產品。Java 是原Sun Microsystems公司推出的面向物件的程式設計語言，特別適合於網際網路應用程式開發;而Java是Netscape公司的產品，為了擴充套件Netscape瀏覽器的功能而開發的一種可以嵌入Web頁面中執行的基於物件和事件驅動的解釋性語言。Java的前身是Live;而Java的前身是Oak語言。
　　下面對兩種語言間的異同作如下比較：
　　- 基於物件和麵向物件：Java是一種真正的面向物件的語言，即使是開發簡單的程式，必須設計物件;Java是種指令碼語言，它可以用來製作與網路無關的，與使用者互動作用的複雜軟體。它是一種基於物件(Object-Based)和事件驅動(Event-Driven)的程式語言，因而它本身提供了非常豐富的內部物件供設計人員使用。
　　- 解釋和編譯：Java的原始碼在執行之前，必須經過編譯。Java是一種解釋性程式語言，其原始碼不需經過編譯，由瀏覽器解釋執行。(目前的瀏覽器幾乎都使用了JIT(即時編譯)技術來提升Java的執行效率)
　　- 強型別變數和型別弱變數：Java採用強型別變數檢查，即所有變數在編譯之前必須作宣告;Java中變數是弱型別的，甚至在使用變數前可以不作宣告，Java的直譯器在執行時檢查推斷其資料型別。
　　- 程式碼格式不一樣。
　　19、Java堆的結構是什麼樣子的?什麼是堆中的永久代(Perm Gen space)?
　　JVM的堆是執行時資料區，所有類的例項和陣列都是在堆上分配記憶體。它在JVM啟動的時候被建立。物件所佔的堆記憶體是由自動記憶體管理系統也就是垃圾收集器回收。
　　堆記憶體是由存活和死亡的物件組成的。存活的物件是應用可以訪問的，不會被垃圾回收。死亡的物件是應用不可訪問尚且還沒有被垃圾收集器回收掉的物件。一直到垃圾收集器把這些物件回收掉之前，他們會一直佔據堆記憶體空間。
　　20、闡述ArrayList、Vector、LinkedList的儲存效能和特性。
　　答：ArrayList 和Vector都是使用陣列方式儲存資料，此陣列元素數大於實際儲存的資料以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及陣列元素移動等記憶體操作，所以索引資料快而插入資料慢，Vector中的方法由於添加了synchronized修飾，因此Vector是執行緒安全的容器，但效能上較ArrayList差，因此已經是Java中的遺留容器。LinkedList使用雙向連結串列實現儲存(將記憶體中零散的記憶體單元通過附加的引用關聯起來，形成一個可以按序號索引的線性結構，這種鏈式儲存方式與陣列的連續儲存方式相比，記憶體的利用率更高)，按序號索引資料需要進行前向或後向遍歷，但是插入資料時只需要記錄本項的前後項即可，所以插入速度較快。Vector屬於遺留容器(Java早期的版本中提供的容器，除此之外，Hashtable、Dictionary、BitSet、Stack、Properties都是遺留容器)，已經不推薦使用，但是由於ArrayList和LinkedListed都是非執行緒安全的，如果遇到多個執行緒操作同一個容器的場景，則可以通過工具類Collections中的synchronizedList方法將其轉換成執行緒安全的容器後再使用(這是對裝潢模式的應用，將已有物件傳入另一個類的構造器中建立新的物件來增強實現)。
　　補充：遺留容器中的Properties類和Stack類在設計上有嚴重的問題，Properties是一個鍵和值都是字串的特殊的鍵值對對映，在設計上應該是關聯一個Hashtable並將其兩個泛型引數設定為String型別，但是Java API中的Properties直接繼承了Hashtable，這很明顯是對繼承的濫用。這裡複用程式碼的方式應該是Has-A關係而不是Is-A關係，另一方面容器都屬於工具類，繼承工具類本身就是一個錯誤的做法，使用工具類最好的方式是Has-A關係(關聯)或Use-A關係(依賴)。同理，Stack類繼承Vector也是不正確的。Sun公司的工程師們也會犯這種低階錯誤，讓人唏噓不已。