1）Java 中能創建 volatile 數組嗎？
能，Java 中可以創建 volatile 類型數組，不過只是一個指向數組的引用，而不是整個數組。我的意思是，如果改變引用指向的數組，將會受到 volatile 的保護，但是如果多個線程同時改變數組的元素，volatile 標示符就不能起到之前的保護作用了。

2）volatile 能使得一個非原子操作變成原子操作嗎？
一個典型的例子是在類中有一個 long 類型的成員變量。如果你知道該成員變量會被多個線程訪問，如計數器、價格等，你最好是將其設置為 volatile。為什么？因為 Java 中讀取 long 類型變量不是原子的，需要分成兩步，如果一個線程正在修改該 long 變量的值，另一個線程可能只能看到該值的一半（前 32 位）。但是對一個 volatile 型的 long 或 double 變量的讀寫是原子。

3）volatile 修飾符的有過什么實踐？
一種實踐是用 volatile 修飾 long 和 double 變量，使其能按原子類型來讀寫。double 和 long 都是64位寬，因此對這兩種類型的讀是分為兩部分的，第一次讀取第一個 32 位，然后再讀剩下的 32 位，這個過程不是原子的，但 Java 中 volatile 型的 long 或 double 變量的讀寫是原子的。volatile 修復符的另一個作用是提供內存屏障（memory barrier），例如在分布式框架中的應用。簡單的說，就是當你寫一個 volatile 變量之前，Java 內存模型會插入一個寫屏障（write barrier），讀一個 volatile 變量之前，會插入一個讀屏障（read barrier）。意思就是說，在你寫一個 volatile 域時，能保證任何線程都能看到你寫的值，同時，在寫之前，也能保證任何數值的更新對所有線程是可見的，因為內存屏障會將其他所有寫的值更新到緩存。

4）volatile 類型變量提供什么保證？
volatile 變量提供順序和可見性保證，例如，JVM 或者 JIT為了獲得更好的性能會對語句重排序，但是 volatile 類型變量即使在沒有同步塊的情況下賦值也不會與其他語句重排序。 volatile 提供 happens-before 的保證，確保一個線程的修改能對其他線程是可見的。某些情況下，volatile 還能提供原子性，如讀 64 位數據類型，像 long 和 double 都不是原子的，但 volatile 類型的 double 和 long 就是原子的。

5）你是如何調用 wait（）方法的？使用 if 塊還是循環？為什么？
wait() 方法應該在循環調用，因為當線程獲取到 CPU 開始執行的時候，其他條件可能還沒有滿足，所以在處理前，循環檢測條件是否滿足會更好。下面是一段標準的使用 wait 和 notify 方法的代碼：

// The standard idiom for using the wait method
synchronized (obj) {
while (condition does not hold)
obj.wait(); // (Releases lock, and reacquires on wakeup)
... // Perform action appropriate to condition
}


6）什么是多線程環境下的偽共享（false sharing）？
偽共享是多線程系統（每個處理器有自己的局部緩存）中一個眾所周知的性能問題。偽共享發生在不同處理器的上的線程對變量的修改依賴于相同的緩存行，如下圖所示：





7）什么是 Busy spin？我們為什么要使用它？
Busy spin 是一種在不釋放 CPU 的基礎上等待事件的技術。它經常用于避免丟失 CPU 緩存中的數據（如果線程先暫停，之后在其他CPU上運行就會丟失）。所以，如果你的工作要求低延遲，并且你的線程目前沒有任何順序，這樣你就可以通過循環 檢測隊列中的新消息來代替調用 sleep() 或 wait() 方法。它唯一的好處就是你只需等待很短的時間，如幾微秒或幾納秒。LMAX 分布式框架是一個高性能線程間通信的庫，該庫有一個 BusySpinWaitStrategy 類就是基于這個概念實現的，使用 busy spin 循環 EventProcessors 等待屏障。

8）什么是線程局部變量？
線程局部變量是局限于線程內部的變量，屬于線程自身所有，不在多個線程間共享。Java 提供 ThreadLocal 類來支持線程局部變量，是一種實現線程安全的方式。但是在管理環境下（如 web 服務器）使用線程局部變量的時候要特別小心，在這種情況下，工作線程的生命周期比任何應用變量的生命周期都要長。任何線程局部變量一旦在工作完成后沒有釋 放，Java 應用就存在內存泄露的風險。

9）Java 中 sleep 方法和 wait 方法的區別？
雖然兩者都是用來暫停當前運行的線程，但是 sleep() 實際上只是短暫停頓，因為它不會釋放鎖，而 wait() 意味著條件等待，這就是為什么該方法要釋放鎖，因為只有這樣，其他等待的線程才能在滿足條件時獲取到該鎖。

10）什么是不可變對象（immutable object）？Java 中怎么創建一個不可變對象？
不可變對象指對象一旦被創建，狀態就不能再改變。任何修改都會創建一個新的對象，如 String、Integer及其它包裝類。

11）我們能創建一個包含可變對象的不可變對象嗎？
是的，我們是可以創建一個包含可變對象的不可變對象的，你只需要謹慎一點，不要共享可變對象的引用就可以了，如果需要變化時，就返回原對象的一個拷貝。最常見的例子就是對象中包含一個日期對象的引用。

數據類型和 Java 基礎面試問題

12）Java 中應該使用什么數據類型來代表價格？
如果不是特別關心內存和性能的話，使用BigDecimal，否則使用預定義精度的 double 類型。

13）怎么將 byte 轉換為 String？
可以使用 String 接收 byte[] 參數的構造器來進行轉換，需要注意的點是要使用的正確的編碼，否則會使用平臺默認編碼，這個編碼可能跟原來的編碼相同，也可能不同。

14）我們能將 int 強制轉換為 byte 類型的變量嗎？如果該值大于 byte 類型的范圍，將會出現什么現象？
是的，我們可以做強制轉換，但是 Java 中 int 是 32 位的，而 byte 是 8 位的，所以，如果強制轉化是，int 類型的高 24 位將會被丟棄，byte 類型的范圍是從 -128 到 128。

15）Java 中 ++ 操作符是線程安全的嗎？
不是線程安全的操作。它涉及到多個指令，如讀取變量值，增加，然后存儲回內存，這個過程可能會出現多個線程交差。

16）a = a + b 與 a += b 的區別？
+= 隱式的將加操作的結果類型強制轉換為持有結果的類型。如果兩這個整型相加，如 byte、short 或者 int，首先會將它們提升到 int 類型，然后在執行加法操作。如果加法操作的結果比 a 的最大值要大，則 a+b 會出現編譯錯誤，但是 a += b 沒問題，如下：
byte a = 127;
byte b = 127;
b = a + b; // error : cannot convert from int to byte
b += a; // ok

注：其實無論 a+b 的值為多少，編譯器都會報錯，因為 a+b 操作會將 a、b 提升為 int 類型，所以將 int 類型賦值給 byte 就會編譯出錯

17）我能在不進行強制轉換的情況下將一個 double 值賦值給 long 類型的變量嗎？
不行，你不能在沒有強制類型轉換的前提下將一個 double 值賦值給 long 類型的變量，因為 double 類型的范圍比 long 類型更廣，所以必須要進行強制轉換。

18）3*0.1 == 0.3 將會返回什么？true 還是 false？
false，因為有些浮點數不能完全精確的表示出來。

19）int 和 Integer 哪個會占用更多的內存？
Integer 對象會占用更多的內存。Integer 是一個對象，需要存儲對象的元數據。但是 int 是一個原始類型的數據，所以占用的空間更少。

20）為什么 Java 中的 String 是不可變的（Immutable）？
Java 中的 String 不可變是因為 Java 的設計者認為字符串使用非常頻繁，將字符串設置為不可變可以允許多個客戶端之間共享相同的字符串。

21）Java 中的構造器鏈是什么？
當你從一個構造器中調用另一個構造器，就是Java 中的構造器鏈。這種情況只在重載了類的構造器的時候才會出現。

JVM 底層 與 GC（Garbage Collection） 的面試問題

22）64 位 JVM 中，int 的長度是多數？
Java 中，int 類型變量的長度是一個固定值，與平臺無關，都是 32 位。意思就是說，在 32 位 和 64 位 的Java 虛擬機中，int 類型的長度是相同的。

23）Serial 與 Parallel GC之間的不同之處？
Serial 與 Parallel 在GC執行的時候都會引起 stop-the-world。它們之間主要不同 serial 收集器是默認的復制收集器，執行 GC 的時候只有一個線程，而 parallel 收集器使用多個 GC 線程來執行。

24）32 位和 64 位的 JVM，int 類型變量的長度是多數？
32 位和 64 位的 JVM 中，int 類型變量的長度是相同的，都是 32 位或者 4 個字節。

25）Java 中 WeakReference 與 SoftReference的區別？
雖然 WeakReference 與 SoftReference 都有利于提高 GC 和 內存的效率，但是 WeakReference ，一旦失去最后一個強引用，就會被 GC 回收，而軟引用雖然不能阻止被回收，但是可以延遲到 JVM 內存不足的時候。

26）WeakHashMap 是怎么工作的？
WeakHashMap 的工作與正常的 HashMap 類似，但是使用弱引用作為 key，意思就是當 key 對象沒有任何引用時，key/value 將會被回收。

27）JVM 選項 -XX:+UseCompressedOops 有什么作用？為什么要使用？
當你將你的應用從 32 位的 JVM 遷移到 64 位的 JVM 時，由于對象的指針從 32 位增加到了 64 位，因此堆內存會突然增加，差不多要翻倍。這也會對 CPU 緩存（容量比內存小很多）的數據產生不利的影響。因為，遷移到 64 位的 JVM 主要動機在于可以指定最大堆大小，通過壓縮 OOP 可以節省一定的內存。通過 -XX:+UseCompressedOops 選項，JVM 會使用 32 位的 OOP，而不是 64 位的 OOP。

28）怎樣通過 Java 程序來判斷 JVM 是 32 位 還是 64 位？
你可以檢查某些系統屬性如 sun.arch.data.model 或 os.arch 來獲取該信息。

29）32 位 JVM 和 64 位 JVM 的最大堆內存分別是多數？
理論上說上 32 位的 JVM 堆內存可以到達 2^32，即 4GB，但實際上會比這個小很多。不同操作系統之間不同，如 Windows 系統大約 1.5 GB，Solaris 大約 3GB。64 位 JVM允許指定最大的堆內存，理論上可以達到 2^64，這是一個非常大的數字，實際上你可以指定堆內存大小到 100GB。甚至有的 JVM，如 Azul，堆內存到 1000G 都是可能的。

30）JRE、JDK、JVM 及 JIT 之間有什么不同？
JRE 代表 Java 運行時（Java run-time），是運行 Java 引用所必須的。JDK 代表 Java 開發工具（Java development kit），是 Java 程序的開發工具，如 Java 編譯器，它也包含 JRE。JVM 代表 Java 虛擬機（Java virtual machine），它的責任是運行 Java 應用。JIT 代表即時編譯（Just In Time compilation），當代碼執行的次數超過一定的閾值時，會將 Java 字節碼轉換為本地代碼，如，主要的熱點代碼會被準換為本地代碼，這樣有利大幅度提高 Java 應用的性能。

31）解釋 Java 堆空間及 GC？
當通過 Java 命令啟動 Java 進程的時候，會為它分配內存。內存的一部分用于創建堆空間，當程序中創建對象的時候，就從對空間中分配內存。GC 是 JVM 內部的一個進程，回收無效對象的內存用于將來的分配。

32）你能保證 GC 執行嗎？
不能，雖然你可以調用 System.gc() 或者 Runtime.gc()，但是沒有辦法保證 GC 的執行。

33）怎么獲取 Java 程序使用的內存？堆使用的百分比？
可以通過 java.lang.Runtime 類中與內存相關方法來獲取剩余的內存，總內存及最大堆內存。通過這些方法你也可以獲取到堆使用的百分比及堆內存的剩余空間。 Runtime.freeMemory() 方法返回剩余空間的字節數，Runtime.totalMemory() 方法總內存的字節數，Runtime.maxMemory() 返回最大內存的字節數。

34）Java 中堆和棧有什么區別？
JVM 中堆和棧屬于不同的內存區域，使用目的也不同。棧常用于保存方法幀和局部變量，而對象總是在堆上分配。棧通常都比堆小，也不會在多個線程之間共享，而堆被整個 JVM 的所有線程共享。


Java 基本概念面試題

35）“a==b”和”a.equals(b)”有什么區別？
如果 a 和 b 都是對象，則 a==b 是比較兩個對象的引用，只有當 a 和 b 指向的是堆中的同一個對象才會返回 true，而 a.equals(b) 是進行邏輯比較，所以通常需要重寫該方法來提供邏輯一致性的比較。例如，String 類重寫 equals() 方法，所以可以用于兩個不同對象，但是包含的字母相同的比較。

36）a.hashCode() 有什么用？與 a.equals(b) 有什么關系？
hashCode() 方法是相應對象整型的 hash 值。它常用于基于 hash 的集合類，如 Hashtable、HashMap、LinkedHashMap等等。它與 equals() 方法關系特別緊密。根據 Java 規范，兩個使用 equal() 方法來判斷相等的對象，必須具有相同的 hash code。

37）final、finalize 和 finally 的不同之處？
final 是一個修飾符，可以修飾變量、方法和類。如果 final 修飾變量，意味著該變量的值在初始化后不能被改變。finalize 方法是在對象被回收之前調用的方法，給對象自己最后一個復活的機會，但是什么時候調用 finalize 沒有保證。finally 是一個關鍵字，與 try 和 catch 一起用于異常的處理。finally 塊一定會被執行，無論在 try 塊中是否有發生異常。

38）Java 中的編譯期常量是什么？使用它又什么風險？
公共靜態不可變（public static final ）變量也就是我們所說的編譯期常量，這里的 public 可選的。實際上這些變量在編譯時會被替換掉，因為編譯器知道這些變量的值，并且知道這些變量在運行時不能改變。這種方式存在的一個問題是你使用了一個內部 的或第三方庫中的公有編譯時常量，但是這個值后面被其他人改變了，但是你的客戶端仍然在使用老的值，甚至你已經部署了一個新的jar。為了避免這種情況， 當你在更新依賴 JAR 文件時，確保重新編譯你的程序。

Java 集合框架的面試題

39) List、Set、Map 和 Queue 之間的區別？
List 是一個有序集合，允許元素重復。它的某些實現可以提供基于下標值的常量訪問時間，但是這不是 List 接口保證的。Set 是一個無序集合。

40）poll() 方法和 remove() 方法的區別？
poll() 和 remove() 都是從隊列中取出一個元素，但是 poll() 在獲取元素失敗的時候會返回空，但是 remove() 失敗的時候會拋出異常。

41）Java 中 LinkedHashMap 和 PriorityQueue 的區別是什么？
PriorityQueue 保證最高或者最低優先級的的元素總是在隊列頭部，但是 LinkedHashMap 維持的順序是元素插入的順序。當遍歷一個 PriorityQueue 時，沒有任何順序保證，但是 LinkedHashMap 課保證遍歷順序是元素插入的順序。

42）ArrayList 與 LinkedList 的不區別？
最明顯的區別是 ArrrayList 底層的數據結構是數組，支持隨機訪問，而 LinkedList 的底層數據結構書鏈表，不支持隨機訪問。使用下標訪問一個元素，ArrayList 的時間復雜度是 O(1)，而 LinkedList 是 O(n)。

43）用哪兩種方式來實現集合的排序？
你可以使用有序集合，如 TreeSet 或 TreeMap，你也可以使用有順序的的集合，如 list，然后通過 Collections.sort() 來排序。

44）Java 中怎么打印數組？
你可以使用 Arrays.toString() 和 Arrays.deepToString() 方法來打印數組。由于數組沒有實現 toString() 方法，所以如果將數組傳遞給 System.out.println() 方法，將無法打印出數組的內容，但是 Arrays.toString() 可以打印每個元素。

45) Hashtable 與 HashMap 有什么不同之處？
這兩個類有許多不同的地方，下面列出了一部分：
a) Hashtable 是 JDK 1 遺留下來的類，而 HashMap 是后來增加的。
b）Hashtable 是同步的，比較慢，但 HashMap 沒有同步策略，所以會更快。
c）Hashtable 不允許有個空的 key，但是 HashMap 允許出現一個 null key。

46）Java 中的 HashSet，內部是如何工作的？
HashSet 的內部采用 HashMap來實現。由于 Map 需要 key 和 value，所以所有 key 的都有一個默認 value。類似于 HashMap，HashSet 不允許重復的 key，只允許有一個null key，意思就是 HashSet 中只允許存儲一個 null 對象。

47）寫一段代碼在遍歷 ArrayList 時移除一個元素？
該問題的關鍵在于面試者使用的是 ArrayList 的 remove() 還是 Iterator 的 remove()方法。這有一段示例代碼，是使用正確的方式來實現在遍歷的過程中移除元素，而不會出現 ConcurrentModificationException 異常的示例代碼。

48）我們能自己寫一個容器類，然后使用 for-each 循環碼？
可以，你可以寫一個自己的容器類。如果你想使用 Java 中增強的循環來遍歷，你只需要實現 Iterable 接口。如果你實現 Collection 接口，默認就具有該屬性。

49）ArrayList 和 HashMap 的默認大小是多數？
在 Java 7 中，ArrayList 的默認大小是 10 個元素，HashMap 的默認大小是16個元素（必須是2的冪）。這就是 Java 7 中 ArrayList 和 HashMap 類的代碼片段：

// from ArrayList.java JDK 1.7
private static final int DEFAULT_CAPACITY = 10;

//from HashMap.java JDK 7
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

50）有沒有可能兩個不相等的對象有有相同的 hashcode？
有可能，兩個不相等的對象可能會有相同的 hashcode 值，這就是為什么在 hashmap 中會有沖突。相等 hashcode 值的規定只是說如果兩個對象相等，必須有相同的hashcode 值，但是沒有關于不相等對象的任何規定。

51）兩個相同的對象會有不同的的 hash code 嗎？
不能，根據 hash code 的規定，這是不可能的。

52）我們可以在 hashcode() 中使用隨機數字嗎？
不行，因為對象的 hashcode 值必須是相同的。參見答案獲取更多關于 Java 中重寫 hashCode() 方法的知識。

53）Java 中，Comparator 與 Comparable 有什么不同？
Comparable 接口用于定義對象的自然順序，而 comparator 通常用于定義用戶定制的順序。Comparable 總是只有一個，但是可以有多個 comparator 來定義對象的順序。

54）為什么在重寫 equals 方法的時候需要重寫 hashCode 方法？
因為有強制的規范指定需要同時重寫 hashcode 與 equal 是方法，許多容器類，如 HashMap、HashSet 都依賴于 hashcode 與 equals 的規定。

Java 最佳實踐的面試問題

55）Java 中，編寫多線程程序的時候你會遵循哪些最佳實踐？
a）給線程命名，這樣可以幫助調試。
b）最小化同步的范圍，而不是將整個方法同步，只對關鍵部分做同步。
c）如果可以，更偏向于使用 volatile 而不是 synchronized。
d）使用更高層次的并發工具，而不是使用 wait() 和 notify() 來實現線程間通信，如 BlockingQueue，CountDownLatch 及 Semeaphore。
e）優先使用并發集合，而不是對集合進行同步。并發集合提供更好的可擴展性。

56）說出幾點 Java 中使用 Collections 的最佳實踐？
a）使用正確的集合類，例如，如果不需要同步列表，使用 ArrayList 而不是 Vector。
b）優先使用并發集合，而不是對集合進行同步。并發集合提供更好的可擴展性。
c）使用接口代表和訪問集合，如使用List存儲 ArrayList，使用 Map 存儲 HashMap 等等。
d）使用迭代器來循環集合。
e）使用集合的時候使用泛型。

57）說出在 Java 中使用線程的最佳實踐？
a）對線程命名
b）將線程和任務分離，使用線程池執行器來執行 Runnable 或 Callable。
c）使用線程池

58）說出 IO 的最佳實踐？
a）使用有緩沖區的 IO 類，而不要單獨讀取字節或字符。
b）使用 NIO 和 NIO2
c）在 finally 塊中關閉流，或者使用 try-with-resource 語句。
d）使用內存映射文件獲取更快的 IO。

59）列出應該遵循的 JDBC 最佳實踐？
a）使用批量的操作來插入和更新數據
b）使用 PreparedStatement 來避免 SQL 異常，并提高性能。
c）使用數據庫連接池
d）通過列名來獲取結果集，不要使用列的下標來獲取。

60）說出幾條 Java 中方法重載的最佳實踐？
a）不要重載這樣的方法：一個方法接收 int 參數，而另個方法接收 Integer 參數。
b）不要重載參數數量一致，而只是參數順序不同的方法。
c）如果重載的方法參數個數多于 5 個，采用可變參數。

Date、Time 及 Calendar 的面試題

61）在多線程環境下，SimpleDateFormat 是線程安全的嗎？
不是，非常不幸，DateFormat 的所有實現，包括 SimpleDateFormat 都不是線程安全的，因此你不應該在多線程序中使用，除非是在對外線程安全的環境中使用，如 將 SimpleDateFormat 限制在 ThreadLocal 中。如果你不這么做，在解析或者格式化日期的時候，可能會獲取到一個不正確的結果。因此，從日期、時間處理的所有實踐來說，我強力推薦 joda-time 庫。

62）Java 中如何格式化一個日期？如格式化為 ddMMyyyy 的形式？
Java 中，可以使用 SimpleDateFormat 類或者 joda-time 庫來格式日期。DateFormat 類允許你使用多種流行的格式來格式化日期。參見答案中的示例代碼，代碼中演示了將日期格式化成不同的格式，如 dd-MM-yyyy 或 ddMMyyyy。

關于 OOP 和設計模式的面試題

63）接口是什么？為什么要使用接口而不是直接使用具體類？
接口用于定義 API。它定義了類必須得遵循的規則。同時，它提供了一種抽象，因為客戶端只使用接口，這樣可以有多重實現，如 List 接口，你可以使用可隨機訪問的 ArrayList，也可以使用方便插入和刪除的 LinkedList。接口中不允許寫代碼，以此來保證抽象，但是 Java 8 中你可以在接口聲明靜態的默認方法，這種方法是具體的。

64）Java 中，抽象類與接口之間有什么不同？
Java 中，抽象類和接口有很多不同之處，但是最重要的一個是 Java 中限制一個類只能繼承一個類，但是可以實現多個接口。抽象類可以很好的定義一個家族類的默認行為，而接口能更好的定義類型，有助于后面實現多態機制。關于這個問題的討論請查看答案。

65）除了單例模式，你在生產環境中還用過什么設計模式？
這需要根據你的經驗來回答。一般情況下，你可以說依賴注入，工廠模式，裝飾模式或者觀察者模式，隨意選擇你使用過的一種即可。不過你要準備回答接下的基于你選擇的模式的問題。

66）適配器模式是什么？什么時候使用？
適配器模式提供對接口的轉換。如果你的客戶端使用某些接口，但是你有另外一些接口，你就可以寫一個適配去來連接這些接口。

67）構造器注入和 setter 依賴注入，那種方式更好？
每種方式都有它的缺點和優點。構造器注入保證所有的注入都被初始化，但是 setter 注入提供更好的靈活性來設置可選依賴。如果使用 XML 來描述依賴，Setter 注入的可讀寫會更強。經驗法則是強制依賴使用構造器注入，可選依賴使用 setter 注入。

68）依賴注入和工程模式之間有什么不同？
雖然兩種模式都是將對象的創建從應用的邏輯中分離，但是依賴注入比工程模式更清晰。通過依賴注入，你的類就是 POJO，它只知道依賴而不關心它們怎么獲取。使用工廠模式，你的類需要通過工廠來獲取依賴。因此，使用 DI 會比使用工廠模式更容易測試。

69）適配器模式和裝飾器模式有什么區別？
雖然適配器模式和裝飾器模式的結構類似，但是每種模式的出現意圖不同。適配器模式被用于橋接兩個接口，而裝飾模式的目的是在不修改類的情況下給類增加新的功能。

70）適配器模式和代理模式之前有什么不同？
這個問題與前面的類似，適配器模式和代理模式的區別在于他們的意圖不同。由于適配器模式和代理模式都是封裝真正執行動作的類，因此結構是一致的，但是適配器模式用于接口之間的轉換，而代理模式則是增加一個額外的中間層，以便支持分配、控制或智能訪問。

71）什么是模板方法模式？
模板方法提供算法的框架，你可以自己去配置或定義步驟。例如，你可以將排序算法看做是一個模板。它定義了排序的步驟，但是具體的比較，可以使用 Comparable 或者其語言中類似東西，具體策略由你去配置。列出算法概要的方法就是眾所周知的模板方法。

72）什么時候使用訪問者模式？
訪問者模式用于解決在類的繼承層次上增加操作，但是不直接與之關聯。這種模式采用雙派發的形式來增加中間層。

73）什么時候使用組合模式？
組合模式使用樹結構來展示部分與整體繼承關系。它允許客戶端采用統一的形式來對待單個對象和對象容器。當你想要展示對象這種部分與整體的繼承關系時采用組合模式。

74）繼承和組合之間有什么不同？
雖然兩種都可以實現代碼復用，但是組合比繼承共靈活，因為組合允許你在運行時選擇不同的實現。用組合實現的代碼也比繼承測試起來更加簡單。

75）描述 Java 中的重載和重寫？
重載和重寫都允許你用相同的名稱來實現不同的功能，但是重載是編譯時活動，而重寫是運行時活動。你可以在同一個類中重載方法，但是只能在子類中重寫方法。重寫必須要有繼承。

76）Java 中，嵌套公共靜態類與頂級類有什么不同？
類的內部可以有多個嵌套公共靜態類，但是一個 Java 源文件只能有一個頂級公共類，并且頂級公共類的名稱與源文件名稱必須一致。

77) OOP 中的 組合、聚合和關聯有什么區別？
如果兩個對象彼此有關系，就說他們是彼此相關聯的。組合和聚合是面向對象中的兩種形式的關聯。組合是一種比聚合更強力的關聯。組合中，一個對象是 另一個的擁有者，而聚合則是指一個對象使用另一個對象。如果對象 A 是由對象 B 組合的，則 A 不存在的話，B一定不存在，但是如果 A 對象聚合了一個對象 B，則即使 A 不存在了，B 也可以單獨存在。

78）給我一個符合開閉原則的設計模式的例子？
開閉原則要求你的代碼對擴展開放，對修改關閉。這個意思就是說，如果你想增加一個新的功能，你可以很容易的在不改變已測試過的代碼的前提下增加新 的代碼。有好幾個設計模式是基于開閉原則的，如策略模式，如果你需要一個新的策略，只需要實現接口，增加配置，不需要改變核心邏輯。一個正在工作的例子是 Collections.sort() 方法，這就是基于策略模式，遵循開閉原則的，你不需為新的對象修改 sort() 方法，你需要做的僅僅是實現你自己的 Comparator 接口。

79）什么時候使用享元模式？
享元模式通過共享對象來避免創建太多的對象。為了使用享元模式，你需要確保你的對象是不可變的，這樣你才能安全的共享。JDK 中 String 池、Integer 池以及 Long 池都是很好的使用了享元模式的例子。

轉載于:https://www.cnblogs.com/advise09/p/6121039.html

總結

以上是生活随笔為你收集整理的多线程、并发及线程的基础问题的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。