1.面向對象的特征有哪些方面？
- 抽象：抽象是將一類對象的共同特征總結出來構造類的過程，包括數據抽象和行為抽象兩方面。抽象只關注對象有哪些屬性和行為，并不關注這些行為的細節是什么。
- 繼承：繼承是從已有類得到繼承信息創建新類的過程。提供繼承信息的類被稱為父類（超類、基類）；得到繼承信息的類被稱為子類（派生類）。繼承讓變化中的軟件系統有了一定的延續性，同時繼承也是封裝程序中可變因素的重要手段（如果不能理解請閱讀閻宏博士的《Java與模式》或《設計模式精解》中關于橋梁模式的部分）。
- 封裝：通常認為封裝是把數據和操作數據的方法綁定起來，對數據的訪問只能通過已定義的接口。面向對象的本質就是將現實世界描繪成一系列完全自治、封閉的對象。我們在類中編寫的方法就是對實現細節的一種封裝；我們編寫一個類就是對數據和數據操作的封裝。可以說，封裝就是隱藏一切可隱藏的東西，只向外界提供最簡單的編程接口（可以想想普通洗衣機和全自動洗衣機的差別，明顯全自動洗衣機封裝更好因此操作起來更簡單；我們現在使用的智能手機也是封裝得足夠好的，因為幾個按鍵就搞定了所有的事情）。
- 多態性：多態性是指允許不同子類型的對象對同一消息作出不同的響應。簡單的說就是用同樣的對象引用調用同樣的方法但是做了不同的事情。多態性分為編譯時的多態性和運行時的多態性。如果將對象的方法視為對象向外界提供的服務，那么運行時的多態性可以解釋為：當A系統訪問B系統提供的服務時，B系統有多種提供服務的方式，但一切對A系統來說都是透明的（就像電動剃須刀是A系統，它的供電系統是B系統，B系統可以使用電池供電或者用交流電，甚至還有可能是太陽能，A系統只會通過B類對象調用供電的方法，但并不知道供電系統的底層實現是什么，究竟通過何種方式獲得了動力）。方法重載（overload）實現的是編譯時的多態性（也稱為前綁定），而方法重寫（override）實現的是運行時的多態性（也稱為后綁定）。運行時的多態是面向對象最精髓的東西，要實現多態需要做兩件事：1). 方法重寫（子類繼承父類并重寫父類中已有的或抽象的方法）；2). 對象造型（用父類型引用引用子類型對象，這樣同樣的引用調用同樣的方法就會根據子類對象的不同而表現出不同的行為）。
2.String 是最基本的數據類型嗎？
不是。Java中的基本數據類型只有8個：byte、short、int、long、float、double、char、boolean；除了基本類型（primitive type），剩下的都是引用類型（reference type），Java 5以后引入的枚舉類型也算是一種比較特殊的引用類型。
3.float f=3.4;是否正確？
答:不正確。3.4是雙精度數，將雙精度型（double）賦值給浮點型（float）屬于下轉型（down-casting，也稱為窄化）會造成精度損失，因此需要強制類型轉換float f =(float)3.4; 或者寫成float f =3.4F;。
4.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);其中有隱含的強制類型轉換。
5.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
6.解釋內存中的棧(stack)、堆(heap)和方法區(method area)的用法。
通常我們定義一個基本數據類型的變量，一個對象的引用，還有就是函數調用的現場保存都使用JVM中的棧空間；而通過new關鍵字和構造器創建的對象則放在堆空間，堆是垃圾收集器管理的主要區域，由于現在的垃圾收集器都采用分代收集算法，所以堆空間還可以細分為新生代和老生代，再具體一點可以分為Eden、Survivor（又可分為From Survivor和To Survivor）、Tenured；方法區和堆都是各個線程共享的內存區域，用于存儲已經被JVM加載的類信息、常量、靜態變量、JIT編譯器編譯后的代碼等數據；程序中的字面量（literal）如直接書寫的100、"hello"和常量都是放在常量池中，常量池是方法區的一部分，。棧空間操作起來最快但是棧很小，通常大量的對象都是放在堆空間，棧和堆的大小都可以通過JVM的啟動參數來進行調整，棧空間用光了會引發StackOverflowError，而堆和常量池空間不足則會引發OutOfMemoryError。
7.Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？
Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在參數上加0.5然后進行下取整。
8.switch 是否能作用在byte 上，是否能作用在long 上，是否能作用在String上？
在Java 5以前，switch(expr)中，expr只能是byte、short、char、int。從Java 5開始，Java中引入了枚舉類型，expr也可以是enum類型，從Java 7開始，expr還可以是字符串（String），但是長整型（long）在目前所有的版本中都是不可以的。
9.用最有效率的方法計算2乘以8？
2 << 3（左移3位相當于乘以2的3次方，右移3位相當于除以2的3次方）。
我們為編寫的類重寫hashCode方法時，可能會看到如下所示的代碼，其實我們不太理解為什么要使用這樣的乘法運算來產生哈希碼（散列碼），而且為什么這個數是個素數，為什么通常選擇31這個數？前兩個問題的答案你可以自己百度一下，選擇31是因為可以用移位和減法運算來代替乘法，從而得到更好的性能。說到這里你可能已經想到了：31 * num 等價于(num << 5) - num，左移5位相當于乘以2的5次方再減去自身就相當于乘以31，現在的VM都能自動完成這個優化。
10.構造器（constructor）是否可被重寫（override）？
構造器不能被繼承，因此不能被重寫，但可以被重載。
11.兩個對象值相同(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注解。
12.當一個對象被當作參數傳遞到一個方法后，此方法可改變這個對象的屬性，并可返回變化后的結果，那么這里到底是值傳遞還是引用傳遞？
答：是值傳遞。Java語言的方法調用只支持參數的值傳遞。當一個對象實例作為一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的屬性可以在被調用過程中被改變，但對對象引用的改變是不會影響到調用者的。C++和C#中可以通過傳引用或傳輸出參數來改變傳入的參數的值。在C#中可以編寫如下所示的代碼，但是在Java中卻做不到。
13.String和StringBuilder、StringBuffer的區別？
Java平臺提供了兩種類型的字符串：String和StringBuffer/StringBuilder，它們可以儲存和操作字符串。其中String是只讀字符串，也就意味著String引用的字符串內容是不能被改變的。而StringBuffer/StringBuilder類表示的字符串對象可以直接進行修改。StringBuilder是Java 5中引入的，它和StringBuffer的方法完全相同，區別在于它是在單線程環境下使用的，因為它的所有方面都沒有被synchronized修飾，因此它的效率也比StringBuffer要高。
14.描述一下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所指定的目錄中記載類，是用戶自定義加載器的默認父加載器。
15.char 型變量中能不能存貯一個中文漢字，為什么？
char類型可以存儲一個中文漢字，因為Java中使用的編碼是Unicode（不選擇任何特定的編碼，直接使用字符在字符集中的編號，這是統一的唯一方法），一個char類型占2個字節（16比特），所以放一個中文是沒問題的。
使用Unicode意味著字符在JVM內部和外部有不同的表現形式，在JVM內部都是Unicode，當這個字符被從JVM內部轉移到外部時（例如存入文件系統中），需要進行編碼轉換。所以Java中有字節流和字符流，以及在字符流和字節流之間進行轉換的轉換流，如InputStreamReader和OutputStreamReader，這兩個類是字節流和字符流之間的適配器類，承擔了編碼轉換的任務；對于C程序員來說，要完成這樣的編碼轉換恐怕要依賴于union（聯合體/共用體）共享內存的特征來實現了。
16.抽象類（abstract class）和接口（interface）有什么異同？
抽象類和接口都不能夠實例化，但可以定義抽象類和接口類型的引用。一個類如果繼承了某個抽象類或者實現了某個接口都需要對其中的抽象方法全部進行實現，否則該類仍然需要被聲明為抽象類。接口比抽象類更加抽象，因為抽象類中可以定義構造器，可以有抽象方法和具體方法，而接口中不能定義構造器而且其中的方法全部都是抽象方法。抽象類中的成員可以是private、默認、protected、public的，而接口中的成員全都是public的。抽象類中可以定義成員變量，而接口中定義的成員變量實際上都是常量。有抽象方法的類必須被聲明為抽象類，而抽象類未必要有抽象方法。
17.靜態嵌套類(Static Nested Class)和內部類（Inner Class）的不同？
答：Static Nested Class是被聲明為靜態（static）的內部類，它可以不依賴于外部類實例被實例化。而通常的內部類需要在外部類實例化后才能實例化，其語法看起來挺詭異的，如下所示。
面試題 - 下面的代碼哪些地方會產生編譯錯誤？
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();
18.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;
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。
19.抽象的（abstract）方法是否可同時是靜態的（static）,是否可同時是本地方法（native），是否可同時被synchronized修飾？
都不能。抽象方法需要子類重寫，而靜態的方法是無法被重寫的，因此二者是矛盾的。本地方法是由本地代碼（如C代碼）實現的方法，而抽象方法是沒有實現的，也是矛盾的。synchronized和方法的實現細節有關，抽象方法不涉及實現細節，因此也是相互矛盾的。
20.如何實現對象克隆？
有兩種方式：
1). 實現Cloneable接口并重寫Object類中的clone()方法；
2). 實現Serializable接口，通過對象的序列化和反序列化實現克隆，可以實現真正的深度克隆，代碼如下。
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class MyUtil {
private MyUtil() {
throw new AssertionError();
}
@SuppressWarnings("unchecked")
public static <T extends Serializable> 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方法沒有任何意義
// 這兩個基于內存的流只要垃圾回收器清理對象就能夠釋放資源，這一點不同于對外部資源（如文件流）的釋放
}
}
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();
}
}
}
21.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：設置幸存區的目標使用率
22.String s = new String("xyz");創建了幾個字符串對象？
兩個對象，一個是靜態區的"xyz"，一個是用new創建在堆上的對象。
23.Anonymous Inner Class(匿名內部類)是否可以繼承其它類？是否可以實現接口？
可以繼承其他類或實現其他接口，在Swing編程和Android開發中常用此方式來實現事件監聽和回調。
24.指出下面程序的運行結果。
class A {
static {
System.out.print("1");
}
public A() {
System.out.print("2");
}
}
class B extends A{
static {
System.out.print("a");
}
public B() {
System.out.print("b");
}
}
public class Hello {
public static void main(String[] args) {
A ab = new B();
ab = new B();
}
}
執行結果：1a2b2b。創建對象時構造器的調用順序是：先初始化靜態成員，然后調用父類構造器，再初始化非靜態成員，最后調用自身構造器。
25.怎樣將GB2312編碼的字符串轉換為ISO-8859-1編碼的字符串？
String s1 = "你好";
String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");
26.Error和Exception有什么區別？
Error表示系統級的錯誤和程序不必處理的異常，是恢復不是不可能但很困難的情況下的一種嚴重問題；比如內存溢出，不可能指望程序能處理這樣的情況；Exception表示需要捕捉或者需要程序進行處理的異常，是一種設計或實現問題；也就是說，它表示如果程序運行正常，從不會發生的情況。
面試題：2005年摩托羅拉的面試中曾經問過這么一個問題“If a process reports a stack overflow run-time error, what’s the most possible cause?”，給了四個選項a. lack of memory; b. write on an invalid memory space; c. recursive function calling; d. array index out of boundary. Java程序在運行時也可能會遭遇StackOverflowError，這是一個無法恢復的錯誤，只能重新修改代碼了，這個面試題的答案是c。如果寫了不能迅速收斂的遞歸，則很有可能引發棧溢出的錯誤，如下所示：
class StackOverflowErrorTest {
public static void main(String[] args) {
main(null);
}
}
27.try{}里有一個return語句，那么緊跟在這個try后的finally{}里的代碼會不會被執行，什么時候被執行，在return前還是后?
會執行，在方法返回調用者前執行。
注意：在finally中改變返回值的做法是不好的，因為如果存在finally代碼塊，try中的return語句不會立馬返回調用者，而是記錄下返回值待finally代碼塊執行完畢之后再向調用者返回其值，然后如果在finally中修改了返回值，就會返回修改后的值。顯然，在finally中返回或者修改返回值會對程序造成很大的困擾，C#中直接用編譯錯誤的方式來阻止程序員干這種齷齪的事情，Java中也可以通過提升編譯器的語法檢查級別來產生警告或錯誤，Eclipse中可以在如圖所示的地方進行設置，強烈建議將此項設置為編譯錯誤。
28.列出一些你常見的運行時異常？
- ArithmeticException（算術異常）
- ClassCastException （類轉換異常）
- IllegalArgumentException （非法參數異常）
- IndexOutOfBoundsException （下標越界異常）
- NullPointerException （空指針異常）
- SecurityException （安全異常）
29.List、Set、Map是否繼承自Collection接口？
答：List、Set 是，Map 不是。Map是鍵值對映射容器，與List和Set有明顯的區別，而Set存儲的零散的元素且不允許有重復元素（數學中的集合也是如此），List是線性結構的容器，適用于按數值索引訪問元素的情形。
30.闡述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公司的工程師們也會犯這種低級錯誤，讓人唏噓不已。
31.TreeMap和TreeSet在排序時如何比較元素？Collections工具類中的sort()方法如何比較元素？
TreeSet要求存放的對象所屬的類必須實現Comparable接口，該接口提供了比較元素的compareTo()方法，當插入元素時會回調該方法比較元素的大小。TreeMap要求存放的鍵值對映射的鍵必須實現Comparable接口從而根據鍵對元素進行排序。Collections工具類的sort方法有兩種重載的形式，第一種要求傳入的待排序容器中存放的對象比較實現Comparable接口以實現元素的比較；第二種不強制性的要求容器中的元素必須可比較，但是要求傳入第二個參數，參數是Comparator接口的子類型（需要重寫compare方法實現元素的比較），相當于一個臨時定義的排序規則，其實就是通過接口注入比較元素大小的算法，也是對回調模式的應用（Java中對函數式編程的支持）。
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
class Test02 {
public static void main(String[] args) {
List<Student> list = new ArrayList<>(); // Java 7的鉆石語法(構造器后面的尖括號中不需要寫類型)
list.add(new Student("Hao LUO", 33));
list.add(new Student("XJ WANG", 32));
list.add(new Student("Bruce LEE", 60));
list.add(new Student("Bob YANG", 22));
// 通過sort方法的第二個參數傳入一個Comparator接口對象
// 相當于是傳入一個比較對象大小的算法到sort方法中
// 由于Java中沒有函數指針、仿函數、委托這樣的概念
// 因此要將一個算法傳入一個方法中唯一的選擇就是通過接口回調
Collections.sort(list, new Comparator<Student> () {
@Override
public int compare(Student o1, Student o2) {
return o1.getName().compareTo(o2.getName()); // 比較學生姓名
}
});
for(Student stu : list) {
System.out.println(stu);
}
// 輸出結果:
// Student [name=Bob YANG, age=22]
// Student [name=Bruce LEE, age=60]
// Student [name=Hao LUO, age=33]
// Student [name=XJ WANG, age=32]
}
}
32.Thread類的sleep()方法和對象的wait()方法都可以讓線程暫停執行，它們有什么區別?
sleep()方法（休眠）是線程類（Thread）的靜態方法，調用此方法會讓當前線程暫停執行指定的時間，將執行機會（CPU）讓給其他線程，但是對象的鎖依然保持，因此休眠時間結束后會自動恢復（線程回到就緒狀態，請參考第66題中的線程狀態轉換圖）。wait()是Object類的方法，調用對象的wait()方法導致當前線程放棄對象的鎖（線程暫停執行），進入對象的等待池（wait pool），只有調用對象的notify()方法（或notifyAll()方法）時才能喚醒等待池中的線程進入等鎖池（lock pool），如果線程重新獲得對象的鎖就可以進入就緒狀態。
補充：可能不少人對什么是進程，什么是線程還比較模糊，對于為什么需要多線程編程也不是特別理解。簡單的說：進程是具有一定獨立功能的程序關于某個數據集合上的一次運行活動，是操作系統進行資源分配和調度的一個獨立單位；線程是進程的一個實體，是CPU調度和分派的基本單位，是比進程更小的能獨立運行的基本單位。線程的劃分尺度小于進程，這使得多線程程序的并發性高；進程在執行時通常擁有獨立的內存單元，而線程之間可以共享內存。使用多線程的編程通常能夠帶來更好的性能和用戶體驗，但是多線程的程序對于其他程序是不友好的，因為它可能占用了更多的CPU資源。當然，也不是線程越多，程序的性能就越好，因為線程之間的調度和切換也會浪費CPU時間。時下很時髦的Node.js就采用了單線程異步I/O的工作模式。
33.線程的sleep()方法和yield()方法有什么區別？
① sleep()方法給其他線程運行機會時不考慮線程的優先級，因此會給低優先級的線程以運行的機會；yield()方法只會給相同優先級或更高優先級的線程以運行的機會；
② 線程執行sleep()方法后轉入阻塞（blocked）狀態，而執行yield()方法后轉入就緒（ready）狀態；
③ sleep()方法聲明拋出InterruptedException，而yield()方法沒有聲明任何異常；
④ sleep()方法比yield()方法（跟操作系統CPU調度相關）具有更好的可移植性。
34.當一個線程進入一個對象的synchronized方法A之后，其它線程是否可進入此對象的synchronized方法B？
不能。其它線程只能訪問該對象的非同步方法，同步方法則不能進入。因為非靜態方法上的synchronized修飾符要求執行方法時要獲得對象的鎖，如果已經進入A方法說明對象鎖已經被取走，那么試圖進入B方法的線程就只能在等鎖池（注意不是等待池哦）中等待對象的鎖。
35.synchronized關鍵字的用法？
synchronized關鍵字可以將對象或者方法標記為同步，以實現對對象和方法的互斥訪問，可以用synchronized(對象) { … }定義同步代碼塊，或者在聲明方法時將synchronized作為方法的修飾符。在第60題的例子中已經展示了synchronized關鍵字的用法。
36.什么是線程池（thread pool）？
在面向對象編程中，創建和銷毀對象是很費時間的，因為創建一個對象要獲取內存資源或者其它更多資源。在Java中更是如此，虛擬機將試圖跟蹤每一個對象，以便能夠在對象銷毀后進行垃圾回收。所以提高服務程序效率的一個手段就是盡可能減少創建和銷毀對象的次數，特別是一些很耗資源的對象創建和銷毀，這就是”池化資源”技術產生的原因。線程池顧名思義就是事先創建若干個可執行的線程放入一個池（容器）中，需要的時候從池中獲取線程不用自行創建，使用完畢不需要銷毀線程而是放回池中，從而減少創建和銷毀線程對象的開銷。
Java 5+中的Executor接口定義一個執行線程的工具。它的子類型即線程池接口是ExecutorService。要配置一個線程池是比較復雜的，尤其是對于線程池的原理不是很清楚的情況下，因此在工具類Executors面提供了一些靜態工廠方法，生成一些常用的線程池，如下所示：
- newSingleThreadExecutor：創建一個單線程的線程池。這個線程池只有一個線程在工作，也就是相當于單線程串行執行所有任務。如果這個唯一的線程因為異常結束，那么會有一個新的線程來替代它。此線程池保證所有任務的執行順序按照任務的提交順序執行。
- newFixedThreadPool：創建固定大小的線程池。每次提交一個任務就創建一個線程，直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變，如果某個線程因為執行異常而結束，那么線程池會補充一個新線程。
- newCachedThreadPool：創建一個可緩存的線程池。如果線程池的大小超過了處理任務所需要的線程，那么就會回收部分空閑（60秒不執行任務）的線程，當任務數增加時，此線程池又可以智能的添加新線程來處理任務。此線程池不會對線程池大小做限制，線程池大小完全依賴于操作系統（或者說JVM）能夠創建的最大線程大小。
- newScheduledThreadPool：創建一個大小無限的線程池。此線程池支持定時以及周期性執行任務的需求。
- newSingleThreadExecutor：創建一個單線程的線程池。此線程池支持定時以及周期性執行任務的需求。
37.簡述synchronized 和java.util.concurrent.locks.Lock的異同？
Lock是Java 5以后引入的新的API，和關鍵字synchronized相比主要相同點：Lock 能完成synchronized所實現的所有功能；主要不同點：Lock有比synchronized更精確的線程語義和更好的性能，而且不強制性的要求一定要獲得鎖。synchronized會自動釋放鎖，而Lock一定要求程序員手工釋放，并且最好在finally 塊中釋放（這是釋放外部資源的最好的地方）。
38.Java中如何實現序列化，有什么意義？
序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化。可以對流化后的對象進行讀寫操作，也可將流化后的對象傳輸于網絡之間。序列化是為了解決對象流讀寫操作時可能引發的問題（如果不進行序列化可能會存在數據亂序的問題）。
要實現序列化，需要讓一個類實現Serializable接口，該接口是一個標識性接口，標注該類對象是可被序列化的，然后使用一個輸出流來構造一個對象輸出流并通過writeObject(Object)方法就可以將實現對象寫出（即保存其狀態）；如果需要反序列化則可以用一個輸入流建立對象輸入流，然后通過readObject方法從流中讀取對象。序列化除了能夠實現對象的持久化之外，還能夠用于對象的深度克隆（可以參考第29題）。
39.Java中有幾種類型的流？
字節流和字符流。字節流繼承于InputStream、OutputStream，字符流繼承于Reader、Writer。在java.io 包中還有許多其他的流，主要是為了提高性能和使用方便。關于Java的I/O需要注意的有兩點：一是兩種對稱性（輸入和輸出的對稱性，字節和字符的對稱性）；二是兩種設計模式（適配器模式和裝潢模式）。另外Java中的流不同于C#的是它只有一個維度一個方向。
面試題 - 編程實現文件拷貝。（這個題目在筆試的時候經常出現，下面的代碼給出了兩種實現方案）
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public final class MyUtil {
private MyUtil() {
throw new AssertionError();
}
public static void fileCopy(String source, String target) throws IOException {
try (InputStream in = new FileInputStream(source)) {
try (OutputStream out = new FileOutputStream(target)) {
byte[] buffer = new byte[4096];
int bytesToRead;
while((bytesToRead = in.read(buffer)) != -1) {
out.write(buffer, 0, bytesToRead);
}
}
}
}
public static void fileCopyNIO(String source, String target) throws IOException {
try (FileInputStream in = new FileInputStream(source)) {
try (FileOutputStream out = new FileOutputStream(target)) {
FileChannel inChannel = in.getChannel();
FileChannel outChannel = out.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(4096);
while(inChannel.read(buffer) != -1) {
buffer.flip();
outChannel.write(buffer);
buffer.clear();
}
}
}
}
}
40.寫一個方法，輸入一個文件名和一個字符串，統計這個字符串在這個文件中出現的次數。
代碼如下:
import java.io.BufferedReader;
import java.io.FileReader;
public final class MyUtil {
// 工具類中的方法都是靜態方式訪問的因此將構造器私有不允許創建對象(絕對好習慣)
private MyUtil() {
throw new AssertionError();
}
/**
* 統計給定文件中給定字符串的出現次數
*
* @param filename 文件名
* @param word 字符串
* @return 字符串在文件中出現的次數
*/
public static int countWordInFile(String filename, String word) {
int counter = 0;
try (FileReader fr = new FileReader(filename)) {
try (BufferedReader br = new BufferedReader(fr)) {
String line = null;
while ((line = br.readLine()) != null) {
int index = -1;
while (line.length() >= word.length() && (index = line.indexOf(word)) >= 0) {
counter++;
line = line.substring(index + word.length());
}
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
return counter;
}
}
41.闡述JDBC操作數據庫的步驟。
下面的代碼以連接本機的Oracle數據庫為例，演示JDBC操作數據庫的步驟。
//加載驅動。
Class.forName("oracle.jdbc.driver.OracleDriver");
//創建連接。
Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");
//創建語句。
PreparedStatement ps = con.prepareStatement("select * from emp where sal between ? and ?");
ps.setInt(1, 1000);
ps.setInt(2, 3000);
//執行語句。
ResultSet rs = ps.executeQuery();
//處理結果。
while(rs.next()) {
System.out.println(rs.getInt("empno") + " - " + rs.getString("ename"));
}
//關閉資源。
finally {
if(con != null) {
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
42.在進行數據庫編程時，連接池有什么作用？
由于創建連接和釋放連接都有很大的開銷（尤其是數據庫服務器不在本地時，每次建立連接都需要進行TCP的三次握手，釋放連接需要進行TCP四次握手，造成的開銷是不可忽視的），為了提升系統訪問數據庫的性能，可以事先創建若干連接置于連接池中，需要時直接從連接池獲取，使用結束時歸還連接池而不必關閉連接，從而避免頻繁創建和釋放連接所造成的開銷，這是典型的用空間換取時間的策略（浪費了空間存儲連接，但節省了創建和釋放連接的時間）。池化技術在Java開發中是很常見的，在使用線程時創建線程池的道理與此相同。基于Java的開源數據庫連接池主要有：C3P0、Proxool、DBCP、BoneCP、Druid等。
補充：在計算機系統中時間和空間是不可調和的矛盾，理解這一點對設計滿足性能要求的算法是至關重要的。大型網站性能優化的一個關鍵就是使用緩存，而緩存跟上面講的連接池道理非常類似，也是使用空間換時間的策略。可以將熱點數據置于緩存中，當用戶查詢這些數據時可以直接從緩存中得到，這無論如何也快過去數據庫中查詢。當然，緩存的置換策略等也會對系統性能產生重要影響，對于這個問題的討論已經超出了這里要闡述的范圍。
43.事務的ACID是指什么？
- 原子性(Atomic)：事務中各項操作，要么全做要么全不做，任何一項操作的失敗都會導致整個事務的失敗；
- 一致性(Consistent)：事務結束后系統狀態是一致的；
- 隔離性(Isolated)：并發執行的事務彼此無法看到對方的中間狀態；
- 持久性(Durable)：事務完成后所做的改動都會被持久化，即使發生災難性的失敗。通過日志和同步備份可以在故障發生后重建數據。
補充：關于事務，在面試中被問到的概率是很高的，可以問的問題也是很多的。首先需要知道的是，只有存在并發數據訪問時才需要事務。當多個事務訪問同一數據時，可能會存在5類問題，包括3類數據讀取問題（臟讀、不可重復讀和幻讀）和2類數據更新問題（第1類丟失更新和第2類丟失更新）。
44.Java中是如何支持正則表達式操作的？
Java中的String類提供了支持正則表達式操作的方法，包括：matches()、replaceAll()、replaceFirst()、split()。此外，Java中可以用Pattern類表示正則表達式對象，它提供了豐富的API進行各種正則表達式操作，請參考下面面試題的代碼。
面試題： - 如果要從字符串中截取第一個英文左括號之前的字符串，例如：北京市(朝陽區)(西城區)(海淀區)，截取結果為：北京市，那么正則表達式怎么寫？
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class RegExpTest {
public static void main(String[] args) {
String str = "北京市(朝陽區)(西城區)(海淀區)";
Pattern p = Pattern.compile(".*?(?=\\()");
Matcher m = p.matcher(str);
if(m.find()) {
System.out.println(m.group());
}
}
}
45.獲得一個類的類對象有哪些方式？
- 方法1：類型.class，例如：String.class
- 方法2：對象.getClass()，例如："hello".getClass()
- 方法3：Class.forName()，例如：Class.forName("java.lang.String")
46.如何通過反射創建對象？
- 方法1：通過類對象調用newInstance()方法，例如：String.class.newInstance()
- 方法2：通過類對象的getConstructor()或getDeclaredConstructor()方法獲得構造器（Constructor）對象并調用其newInstance()方法創建對象，例如：String.class.getConstructor(String.class).newInstance("Hello");
47.如何通過反射獲取和設置對象私有字段的值？
可以通過類對象的getDeclaredField()方法字段（Field）對象，然后再通過字段對象的setAccessible(true)將其設置為可以訪問，接下來就可以通過get/set方法來獲取/設置字段的值了。下面的代碼實現了一個反射的工具類，其中的兩個靜態方法分別用于獲取和設置私有字段的值，字段可以是基本類型也可以是對象類型且支持多級對象操作，例如ReflectionUtil.get(dog, "owner.car.engine.id");可以獲得dog對象的主人的汽車的引擎的ID號。
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
/**
* 反射工具類
* @author 駱昊
*
*/
public class ReflectionUtil {
private ReflectionUtil() {
throw new AssertionError();
}
/**
* 通過反射取對象指定字段(屬性)的值
* @param target 目標對象
* @param fieldName 字段的名字
* @throws 如果取不到對象指定字段的值則拋出異常
* @return 字段的值
*/
public static Object getValue(Object target, String fieldName) {
Class<?> clazz = target.getClass();
String[] fs = fieldName.split("\\.");
try {
for(int i = 0; i < fs.length - 1; i++) {
Field f = clazz.getDeclaredField(fs[i]);
f.setAccessible(true);
target = f.get(target);
clazz = target.getClass();
}
Field f = clazz.getDeclaredField(fs[fs.length - 1]);
f.setAccessible(true);
return f.get(target);
}
catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 通過反射給對象的指定字段賦值
* @param target 目標對象
* @param fieldName 字段的名稱
* @param value 值
*/
public static void setValue(Object target, String fieldName, Object value) {
Class<?> clazz = target.getClass();
String[] fs = fieldName.split("\\.");
try {
for(int i = 0; i < fs.length - 1; i++) {
Field f = clazz.getDeclaredField(fs[i]);
f.setAccessible(true);
Object val = f.get(target);
if(val == null) {
Constructor<?> c = f.getType().getDeclaredConstructor();
c.setAccessible(true);
val = c.newInstance();
f.set(target, val);
}
target = val;
clazz = target.getClass();
}
Field f = clazz.getDeclaredField(fs[fs.length - 1]);
f.setAccessible(true);
f.set(target, value);
}
catch (Exception e) {
throw new RuntimeException(e);
}
}
}
48.如何通過反射調用對象的方法？
import java.lang.reflect.Method;
class MethodInvokeTest {
public static void main(String[] args) throws Exception {
String str = "hello";
Method m = str.getClass().getMethod("toUpperCase");
System.out.println(m.invoke(str)); // HELLO
}
}
49.簡述一下面向對象的"六原則一法則"。
- 單一職責原則：一個類只做它該做的事情。（單一職責原則想表達的就是"高內聚"，寫代碼最終極的原則只有六個字"高內聚、低耦合"，就如同葵花寶典或辟邪劍譜的中心思想就八個字"欲練此功必先自宮"，所謂的高內聚就是一個代碼模塊只完成一項功能，在面向對象中，如果只讓一個類完成它該做的事，而不涉及與它無關的領域就是踐行了高內聚的原則，這個類就只有單一職責。我們都知道一句話叫"因為專注，所以專業"，一個對象如果承擔太多的職責，那么注定它什么都做不好。這個世界上任何好的東西都有兩個特征，一個是功能單一，好的相機絕對不是電視購物里面賣的那種一個機器有一百多種功能的，它基本上只能照相；另一個是模塊化，好的自行車是組裝車，從減震叉、剎車到變速器，所有的部件都是可以拆卸和重新組裝的，好的乒乓球拍也不是成品拍，一定是底板和膠皮可以拆分和自行組裝的，一個好的軟件系統，它里面的每個功能模塊也應該是可以輕易的拿到其他系統中使用的，這樣才能實現軟件復用的目標。）
- 開閉原則：軟件實體應當對擴展開放，對修改關閉。（在理想的狀態下，當我們需要為一個軟件系統增加新功能時，只需要從原來的系統派生出一些新類就可以，不需要修改原來的任何一行代碼。要做到開閉有兩個要點：①抽象是關鍵，一個系統中如果沒有抽象類或接口系統就沒有擴展點；②封裝可變性，將系統中的各種可變因素封裝到一個繼承結構中，如果多個可變因素混雜在一起，系統將變得復雜而換亂，如果不清楚如何封裝可變性，可以參考《設計模式精解》一書中對橋梁模式的講解的章節。）
- 依賴倒轉原則：面向接口編程。（該原則說得直白和具體一些就是聲明方法的參數類型、方法的返回類型、變量的引用類型時，盡可能使用抽象類型而不用具體類型，因為抽象類型可以被它的任何一個子類型所替代，請參考下面的里氏替換原則。）
- 里氏替換原則：任何時候都可以用子類型替換掉父類型。（關于里氏替換原則的描述，Barbara Liskov女士的描述比這個要復雜得多，但簡單的說就是能用父類型的地方就一定能使用子類型。里氏替換原則可以檢查繼承關系是否合理，如果一個繼承關系違背了里氏替換原則，那么這個繼承關系一定是錯誤的，需要對代碼進行重構。例如讓貓繼承狗，或者狗繼承貓，又或者讓正方形繼承長方形都是錯誤的繼承關系，因為你很容易找到違反里氏替換原則的場景。需要注意的是：子類一定是增加父類的能力而不是減少父類的能力，因為子類比父類的能力更多，把能力多的對象當成能力少的對象來用當然沒有任何問題。）
- 接口隔離原則：接口要小而專，絕不能大而全。（臃腫的接口是對接口的污染，既然接口表示能力，那么一個接口只應該描述一種能力，接口也應該是高度內聚的。例如，琴棋書畫就應該分別設計為四個接口，而不應設計成一個接口中的四個方法，因為如果設計成一個接口中的四個方法，那么這個接口很難用，畢竟琴棋書畫四樣都精通的人還是少數，而如果設計成四個接口，會幾項就實現幾個接口，這樣的話每個接口被復用的可能性是很高的。Java中的接口代表能力、代表約定、代表角色，能否正確的使用接口一定是編程水平高低的重要標識。）
- 合成聚合復用原則：優先使用聚合或合成關系復用代碼。（通過繼承來復用代碼是面向對象程序設計中被濫用得最多的東西，因為所有的教科書都無一例外的對繼承進行了鼓吹從而誤導了初學者，類與類之間簡單的說有三種關系，Is-A關系、Has-A關系、Use-A關系，分別代表繼承、關聯和依賴。其中，關聯關系根據其關聯的強度又可以進一步劃分為關聯、聚合和合成，但說白了都是Has-A關系，合成聚合復用原則想表達的是優先考慮Has-A關系而不是Is-A關系復用代碼，原因嘛可以自己從百度上找到一萬個理由，需要說明的是，即使在Java的API中也有不少濫用繼承的例子，例如Properties類繼承了Hashtable類，Stack類繼承了Vector類，這些繼承明顯就是錯誤的，更好的做法是在Properties類中放置一個Hashtable類型的成員并且將其鍵和值都設置為字符串來存儲數據，而Stack類的設計也應該是在Stack類中放一個Vector對象來存儲數據。記住：任何時候都不要繼承工具類，工具是可以擁有并可以使用的，而不是拿來繼承的。）
- 迪米特法則：迪米特法則又叫最少知識原則，一個對象應當對其他對象有盡可能少的了解。（迪米特法則簡單的說就是如何做到"低耦合"，門面模式和調停者模式就是對迪米特法則的踐行。對于門面模式可以舉一個簡單的例子，你去一家公司洽談業務，你不需要了解這個公司內部是如何運作的，你甚至可以對這個公司一無所知，去的時候只需要找到公司入口處的前臺美女，告訴她們你要做什么，她們會找到合適的人跟你接洽，前臺的美女就是公司這個系統的門面。再復雜的系統都可以為用戶提供一個簡單的門面，Java Web開發中作為前端控制器的Servlet或Filter不就是一個門面嗎，瀏覽器對服務器的運作方式一無所知，但是通過前端控制器就能夠根據你的請求得到相應的服務。調停者模式也可以舉一個簡單的例子來說明，例如一臺計算機，CPU、內存、硬盤、顯卡、聲卡各種設備需要相互配合才能很好的工作，但是如果這些東西都直接連接到一起，計算機的布線將異常復雜，在這種情況下，主板作為一個調停者的身份出現，它將各個設備連接在一起而不需要每個設備之間直接交換數據，這樣就減小了系統的耦合度和復雜度，如下圖所示。迪米特法則用通俗的話來將就是不要和陌生人打交道，如果真的需要，找一個自己的朋友，讓他替你和陌生人打交道。）
50.簡述一下你了解的設計模式。
所謂設計模式，就是一套被反復使用的代碼設計經驗的總結（情境中一個問題經過證實的一個解決方案）。使用設計模式是為了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性。設計模式使人們可以更加簡單方便的復用成功的設計和體系結構。將已證實的技術表述成設計模式也會使新系統開發者更加容易理解其設計思路。
在GoF的《Design Patterns: Elements of Reusable Object-Oriented Software》中給出了三類（創建型[對類的實例化過程的抽象化]、結構型[描述如何將類或對象結合在一起形成更大的結構]、行為型[對在不同的對象之間劃分責任和算法的抽象化]）共23種設計模式，包括：Abstract Factory（抽象工廠模式），Builder（建造者模式），Factory Method（工廠方法模式），Prototype（原始模型模式），Singleton（單例模式）；Facade（門面模式），Adapter（適配器模式），Bridge（橋梁模式），Composite（合成模式），Decorator（裝飾模式），Flyweight（享元模式），Proxy（代理模式）；Command（命令模式），Interpreter（解釋器模式），Visitor（訪問者模式），Iterator（迭代子模式），Mediator（調停者模式），Memento（備忘錄模式），Observer（觀察者模式），State（狀態模式），Strategy（策略模式），Template Method（模板方法模式）， Chain Of Responsibility（責任鏈模式）。
面試被問到關于設計模式的知識時，可以揀最常用的作答，例如：
- 工廠模式：工廠類可以根據條件生成不同的子類實例，這些子類有一個公共的抽象父類并且實現了相同的方法，但是這些方法針對不同的數據進行了不同的操作（多態方法）。當得到子類的實例后，開發人員可以調用基類中的方法而不必考慮到底返回的是哪一個子類的實例。
- 代理模式：給一個對象提供一個代理對象，并由代理對象控制原對象的引用。實際開發中，按照使用目的的不同，代理可以分為：遠程代理、虛擬代理、保護代理、Cache代理、防火墻代理、同步化代理、智能引用代理。
- 適配器模式：把一個類的接口變換成客戶端所期待的另一種接口，從而使原本因接口不匹配而無法在一起使用的類能夠一起工作。
- 模板方法模式：提供一個抽象類，將部分邏輯以具體方法或構造器的形式實現，然后聲明一些抽象方法來迫使子類實現剩余的邏輯。不同的子類可以以不同的方式實現這些抽象方法（多態實現），從而實現不同的業務邏輯。
除此之外，還可以講講上面提到的門面模式、橋梁模式、單例模式、裝潢模式（Collections工具類和I/O系統中都使用裝潢模式）等，反正基本原則就是揀自己最熟悉的、用得最多的作答，以免言多必失。
51.用Java寫一個單例類。
//餓漢式單例
public class Singleton {
private Singleton(){}
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
}
//懶漢式單例
public class Singleton {
private static Singleton instance = null;
private Singleton() {}
public static synchronized Singleton getInstance(){
if (instance == null) instance ＝ new Singleton();
return instance;
}
}
注意：實現一個單例有兩點注意事項，①將構造器私有，不允許外界通過構造器創建對象；②通過公開的靜態方法向外界返回類的唯一實例。這里有一個問題可以思考：Spring的IoC容器可以為普通的類創建單例，它是怎么做到的呢？
52.用Java寫一個冒泡排序。
冒泡排序幾乎是個程序員都寫得出來，但是面試的時候如何寫一個逼格高的冒泡排序卻不是每個人都能做到，下面提供一個參考代碼：
import java.util.Comparator;
/**
* 冒泡排序
*
* @author駱昊
*
*/
public class BubbleSorter implements Sorter {
@Override
public <T extends Comparable<T>> void sort(T[] list) {
boolean swapped = true;
for (int i = 1, len = list.length; i < len && swapped; ++i) {
swapped = false;
for (int j = 0; j < len - i; ++j) {
if (list[j].compareTo(list[j + 1]) > 0) {
T temp = list[j];
list[j] = list[j + 1];
list[j + 1] = temp;
swapped = true;
}
}
}
}
@Override
public <T> void sort(T[] list, Comparator<T> comp) {
boolean swapped = true;
for (int i = 1, len = list.length; i < len && swapped; ++i) {
swapped = false;
for (int j = 0; j < len - i; ++j) {
if (comp.compare(list[j], list[j + 1]) > 0) {
T temp = list[j];
list[j] = list[j + 1];
list[j + 1] = temp;
swapped = true;
}
}
}
}
}
53.用Java寫一個折半查找。
折半查找，也稱二分查找、二分搜索，是一種在有序數組中查找某一特定元素的搜索算法。搜素過程從數組的中間元素開始，如果中間元素正好是要查找的元素，則搜素過程結束；如果某一特定元素大于或者小于中間元素，則在數組大于或小于中間元素的那一半中查找，而且跟開始一樣從中間元素開始比較。如果在某一步驟數組已經為空，則表示找不到指定的元素。這種搜索算法每一次比較都使搜索范圍縮小一半，其時間復雜度是O(logN)。
import java.util.Comparator;
public class MyUtil {
public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {
return binarySearch(x, 0, x.length- 1, key);
}
// 使用循環實現的二分查找
public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {
int low = 0;
int high = x.length - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int cmp = comp.compare(x[mid], key);
if (cmp < 0) {
low= mid + 1;
}
else if (cmp > 0) {
high= mid - 1;
}
else {
return mid;
}
}
return -1;
}
// 使用遞歸實現的二分查找
private static<T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {
if(low <= high) {
int mid = low + ((high -low) >> 1);
if(key.compareTo(x[mid])== 0) {
return mid;
}
else if(key.compareTo(x[mid])< 0) {
return binarySearch(x,low, mid - 1, key);
}
else {
return binarySearch(x,mid + 1, high, key);
}
}
return -1;
}
}
54.java中HashMap,LinkedHashMap,TreeMap，HashTable，ConcurrentHashMap的區別和內部實現機制
LinkedHashMap在存儲的同時，能夠保存用戶插入數據的順序，如果需要輸出用戶插入map的順序可以用它；
TreeMap 插入數據后，對鍵值進行排序，內部是通過紅黑樹實現的；
HashTable 與HashMap的功能相同，區別僅僅是HashTable是線程安全的，即某一時刻只允許一個線程訪問，同時鍵值允許為空；
如果HashTable想要允許多線程訪問，可以用 Collections的synchronizedMap方法使HashMap具有同步的能力，或者使用ConcurrentHashMap。
55.紅黑樹和平衡二叉樹的區別
紅黑樹和平衡二叉樹（AVL樹）類似，都是在進行插入和刪除操作時通過特定操作保持二叉查找樹的平衡，從而獲得較高的查找性能。自從紅黑樹出來后，AVL樹就被放到了博物館里，據說是紅黑樹有更好的效率，更高的統計性能。
紅黑樹和AVL樹的區別在于它使用顏色來標識結點的高度，它所追求的是局部平衡而不是AVL樹中的非常嚴格的平衡。
紅黑樹是一種二叉樹，同時它還滿足下列5個特性：
- 每個節點是紅色或者黑色的。
- 根節點是黑色的。
- 每個葉節點是黑色的。（這里將葉節點的左右空子節點作為一個特殊的節點對待，設定他們必須是黑色的。）
- 如果一個節點是紅色的，則它的左右子節點都必須是黑色的。
- 對任意一個節點來說，從它到葉節點的所有路徑必須包含相同數目的黑色節點。
這部分的定義看得讓人有點不知所云，我們先看一個紅黑樹的示例：
假定其中帶陰影的節點為紅色節點，則上圖為一棵紅黑樹。假定我們取根節點來考察，它到任意一個葉節點要走過3個黑色的節點。這樣，從任意一個節點到葉節點只需要經歷過的黑色節點相同就可以了，可以說這是一個放松了的平衡衡量標準。
