萬字長文，62道Java核心面試題，一次性打包送給積極向上的你

先看再點贊，給自己一點思考的時間，微信搜尋【沉默王二】關注這個靠才華苟且的程式設計師。
本文 GitHub github.com/itwanger 已收錄，裡面還有一線大廠整理的面試題，以及我的系列文章。

二哥，你好，找工作找了仨月，還沒有找到，很焦慮，我該怎麼辦呢？你那有沒有 Java 方面的面試題可以分享一波啊？

以上是讀者田田給我發的私信，看完後於我心有慼慼焉啊，最近境況確實不容樂觀，並非是個人的原因造成的。那，既然需要面試題，二哥就義不容辭，必須得準備一波。

這次我花了兩週的時間，準備了 62 道 Java 核心面試題，希望能夠幫助到田田，以及其他和田田類似情況的讀者朋友。

01、請說出 Java 14 版本中更新的重要功能

Java 14 釋出於 2020 年 3 月 17 日，更新的重要功能有：

• switch 表示式
• instanceof 增強表示式，預覽功能
• 文字塊，第二次預覽
• Records，預覽功能

剛好我之前寫過一篇文章，關於 Java 14 的開箱體驗，很香，讀者朋友需要的話，可以點下面的連結看一看。

Java 14 開箱，它真香香香香

02、請說出 Java 13 版本中更新的重要功能

Java 13 釋出於 2019 年 9 月 17 日，更新的重要功能有：

• 文字塊，預覽功能
• switch 表示式，預覽功能
• Java Socket 重新實現
• FileSystems.newFileSystem() 方法
• 支援 Unicode 12.1
• 可伸縮、低延遲的垃圾收集器改進，用於返回未使用的記憶體

03、請說出 Java 12 版本中更新的重要功能

Java 12 釋出於 2019 年 3 月 19 日，更新的重要功能有：

• JVM 更新
• File.mismatch() 方法
• 緊湊型數字格式
• String 類新增了一些方法，比如說 indent()

04、請說出 Java 11 版本中更新的重要功能

Java 11 是繼 Java 8 之後的第二個商用版本，如果你下載的是 Oracle JDK，則需要進行付費；如果想繼續使用免費版本，需要下載 Open JDK。

Oracle JDK 中會有一些 Open JDK 沒有的、商用閉源的功能。

Java 11 更新的重要功能有：

• 可以直接使用 java 命令執行 Java 程式，原始碼將會隱式編譯和執行。
• String 類新增了一些方法，比如說 isBlank()、lines()、strip() 等等。
• Files 類新增了兩個讀寫方法，readString() 和 writeString()。
• 可以在 Lambda 表示式中使用 var 作為變數型別。

05、請說出 Java 10 版本中更新的重要功能

Java 10 更新的重要功能有：

• 區域性變數型別推斷，舉個例子，var list = new ArrayList();，可以使用 var 來作為變數型別，Java 編譯器知道 list 的型別為字串的 ArrayList。
• 增強 java.util.Locale。
• 提供了一組預設的根證照頒發機構（CA）。

06、請說出 Java 9 版本中更新的重要功能

Java 9 更新的重要功能有：

• 模組系統
• 不可變的 List、Set、Map 的工廠方法
• 介面中可以有私有方法
• 垃圾收集器改進

07、請說出 Java 8 版本中更新的重要功能

Java 8 釋出於 2014 年 3 月份，可以說是 Java 6 之後最重要的版本更新，深受開發者的喜愛。

• 函數語言程式設計和 Lambda 表示式
• Stream 流
• Java Date Time API
• 介面中可以使用預設方法和靜態方法

我強烈建議點開上面的連結閱讀以下，以正確理解這些概念。

08、請說出 Java 物件導向程式設計中的一些重要概念

• 抽象
• 封裝
• 多型
• 繼承

09、Java 聲稱的平臺獨立性指的是什麼？

常見的作業系統有 Windows、Linux、OS-X，那麼平臺獨立性意味著我們可以在任何作業系統中執行相同原始碼的 Java 程式，比如說我們可以在 Windows 上編寫 Java 程式，然後在 Linux 上執行它。

10、什麼是 JVM？

JVM（Java Virtual Machine）俗稱 Java 虛擬機器。之所以稱為虛擬機器，是因為它實際上並不存在。它提供了一種執行環境，可供 Java 位元組碼在上面執行。

JVM 提供了以下操作：

• 載入位元組碼
• 驗證位元組碼
• 執行位元組碼
• 提供執行時環境

JVM 定義了以下內容：

• 儲存區
• 類檔案格式
• 暫存器組
• 垃圾回收堆
• 致命錯誤報告等

我們來嘗試理解一下 JVM 的內部結構，它包含了類載入器（Class Loader）、執行時資料區（Runtime Data Areas）和執行引擎（Excution Engine）。

1）類載入器

類載入器是 JVM 的一個子系統，用於載入類檔案。每當我們執行一個 Java 程式，它都會由類載入器首先載入。Java 中有三個內建的類載入器：

• 啟動類載入器（Bootstrap Class-Loader），載入 jre/lib 包下面的 jar 檔案，比如說常見的 rt.jar（包含了 Java 標準庫下的所有類檔案，比如說 java.lang 包下的類，java.net 包下的類，java.util 包下的類，java.io 包下的類，java.sql 包下的類）。

• 擴充套件類載入器（Extension or Ext Class-Loader），載入 jre/lib/ext 包下面的 jar 檔案。

• 應用類載入器（Application or App Clas-Loader），根據程式的類路徑（classpath）來載入 Java 類。

一般來說，Java 程式設計師並不需要直接同類載入器進行互動。JVM 預設的行為就已經足夠滿足大多數情況的需求了。不過，如果遇到了需要和類載入器進行互動的情況，而對類載入器的機制又不是很瞭解的話，就不得不花大量的時間去除錯
ClassNotFoundException 和 NoClassDefFoundError 等異常。

對於任意一個類，都需要由它的類載入器和這個類本身一同確定其在 JVM 中的唯一性。也就是說，如果兩個類的載入器不同，即使兩個類來源於同一個位元組碼檔案，那這兩個類就必定不相等（比如兩個類的 Class 物件不 equals）。

是不是有點暈，來來來，通過一段簡單的程式碼瞭解下。

public class Test {

    public static void main(String[] args) {
        ClassLoader loader = Test.class.getClassLoader();
        while (loader != null) {
            System.out.println(loader.toString());
            loader = loader.getParent();
        }
    }

}

每個 Java 類都維護著一個指向定義它的類載入器的引用，通過 類名.class.getClassLoader() 可以獲取到此引用；然後通過 loader.getParent() 可以獲取類載入器的上層類載入器。

上面這段程式碼的輸出結果如下：

sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@4617c264

第一行輸出為 Test 的類載入器，即應用類載入器，它是 sun.misc.Launcher$AppClassLoader 類的例項；第二行輸出為擴充套件類載入器，是 sun.misc.Launcher$ExtClassLoader 類的例項。那啟動類載入器呢？

按理說，擴充套件類載入器的上層類載入器是啟動類載入器，但在我這個版本的 JDK 中， 擴充套件類載入器的 getParent() 返回 null。所以沒有輸出。

2）執行時資料區

執行時資料區又包含以下內容。

• PC暫存器（PC Register），也叫程式計數器（Program Counter Register），是一塊較小的記憶體空間，它的作用可以看做是當前執行緒所執行的位元組碼的訊號指示器。

• JVM 棧（Java Virtual Machine Stack），與 PC 暫存器一樣，JVM 棧也是執行緒私有的。每一個 JVM 執行緒都有自己的 JVM 棧，這個棧與執行緒同時建立，它的生命週期與執行緒相同。

• 本地方法棧（Native Method Stack），JVM 可能會使用到傳統的棧來支援 Native 方法（使用 Java 語言以外的其它語言［C語言］編寫的方法）的執行，這個棧就是本地方法棧。

• 堆（Heap），在 JVM 中，堆是可供各條執行緒共享的執行時記憶體區域，也是供所有類例項和資料物件分配記憶體的區域。

• 方法區（Method area），在 JVM 中，被載入型別的資訊都儲存在方法區中。包括型別資訊（Type Information）和方法列表（Method Tables）。方法區是所有執行緒共享的，所以訪問方法區資訊的方法必須是執行緒安全的。

• 執行時常量池（Runtime Constant Pool），執行時常量池是每一個類或介面的常量池在執行時的表現形式，它包括了編譯器可知的數值字面量，以及執行期解析後才能獲得的方法或欄位的引用。簡而言之，當一個方法或者變數被引用時，JVM 通過執行時常量區來查詢方法或者變數在記憶體裡的實際地址。

3）執行引擎

執行引擎包含了：

• 直譯器：讀取位元組碼流，然後執行指令。因為它一條一條地解釋和執行指令，所以它可以很快地解釋位元組碼，但是執行起來會比較慢。

• 即時（Just-In-Time，JIT）編譯器：即時編譯器用來彌補直譯器的缺點，提高效能。執行引擎首先按照解釋執行的方式來執行，然後在合適的時候，即時編譯器把整段位元組碼編譯成原生程式碼。然後，執行引擎就沒有必要再去解釋執行方法了，它可以直接通過原生程式碼去執行。執行原生程式碼比一條一條進行解釋執行的速度快很多。編譯後的程式碼可以執行的很快，因為原生程式碼是儲存在快取裡的。

11、JDK 和 JVM 有什麼區別？

JDK 是 Java Development Kit 的首字母縮寫，是提供給 Java 開發人員的軟體環境，包含 JRE 和一組開發工具。可分為以下版本：

• 標準版（大多數開發人員用的就是這個）
• 企業版
• 微型版

JDK 包含了一個私有的 JVM 和一些其他資源，比如說編譯器（javac 命令）、直譯器（java 命令）等，幫助 Java 程式設計師完成開發工作。

12、JVM 和 JRE 有什麼區別？

Java Runtime Environment（JRE）是 JVM 的實現。JRE 由 JVM 和 Java 二進位制檔案以及其他類組成，可以執行任何程式。JRE 不包含 Java 編譯器，偵錯程式等任何開發工具。

13、哪個類是所有類的超類？

java.lang.Object 是所有 Java 類的超類，我們不需要繼承它，因為是隱式繼承的。

14、為什麼 Java 不支援多重繼承？

如果有兩個類共同繼承（extends）一個有特定方法的父類，那麼該方法會被兩個子類重寫。然後，如果你決定同時繼承這兩個子類，那麼在你呼叫該重寫方法時，編譯器不能識別你要呼叫哪個子類的方法。這也正是著名的菱形問題，見下圖。

ClassC 同時繼承了 ClassA 和 ClassB，ClassC 的物件在呼叫 ClassA 和 ClassB 中過載的方法時，就不知道該呼叫 ClassA 的方法，還是 ClassB 的方法。

15、為什麼 Java 不是純粹的物件導向程式語言？

之所以不能說 Java 是純粹的物件導向程式語言，是因為 Java 支援基本資料型別，比如說 int、short、long、double 等，儘管它們有自己的包裝器型別，但它們的確不能算是物件。

16、path 和 classpath 之間有什麼區別？

path 是作業系統用來查詢可執行檔案的環境變數，我的電腦上就定義了下圖這些 path 變數，比如 Java 和 Maven 的。

classpath 是針對 Java 而言的，用於指定 Java 虛擬機器載入的位元組碼檔案路徑。

17、Java 中 `main()` 方法的重要性是什麼？

每個程式都需要一個入口，對於 Java 程式來說，入口就是 main 方法。

public static void main(String[] args) {}

• public 關鍵字是另外一個訪問修飾符，除了可以宣告方法和變數（所有類可見），還可以宣告類。main() 方法必須宣告為 public。

• static 關鍵字表示該變數或方法是靜態變數或靜態方法，可以直接通過類訪問，不需要例項化物件來訪問。

• void 關鍵字用於指定方法沒有返回值。

另外，main 關鍵字為方法的名字，Java 虛擬機器在執行程式時會尋找這個識別符號；args 為 main() 方法的引數名，它的型別為一個 String 陣列，也就是說，在使用 java 命令執行程式的時候，可以給 main() 方法傳遞字串陣列作為引數。

java HelloWorld 沉默王二 沉默王三

javac 命令用來編譯程式，java 命令用來執行程式，HelloWorld 為這段程式的類名，沉默王二和沉默王三為字串陣列，中間通過空格隔開，然後就可以在 main() 方法中通過 args[0] 和 args[1] 獲取傳遞的引數值了。

public class HelloWorld {
    public static void main(String[] args) {
        if ("沉默王二".equals(args[0])) {

        }

        if ("沉默王三".equals(args[1])) {

        }
    }
}

main() 方法的寫法並不是唯一的，還有其他幾種變體，儘管它們可能並不常見，可以簡單來了解一下。

第二種，把方括號 [] 往 args 靠近而不是 String 靠近：

public static void main(String []args) { }

第三種，把方括號 [] 放在 args 的右側：

public static void main(String args[]) { }

第四種，還可以把陣列形式換成可變引數的形式：

public static void main(String...args) { }

第五種，在 main() 方法上新增另外一個修飾符 strictfp，用於強調在處理浮點數時的相容性：

public strictfp static void main(String[] args) { }

也可以在 main() 方法上新增 final 關鍵字或者 synchronized 關鍵字。

第六種，還可以為 args 引數新增 final 關鍵字：

public static void main(final String[] args) { }

第七種，最複雜的一種，所有可以新增的關鍵字統統新增上：

final static synchronized strictfp void main(final String[] args) { }

當然了，並不需要為了裝逼特意把 main() 方法寫成上面提到的這些形式，使用 IDE 提供的預設形式就可以了。

18、Java 的重寫（Override）和過載（Overload）有什麼區別？

先來看一段重寫的程式碼吧。

class LaoWang{
    public void write() {
        System.out.println("老王寫了一本《基督山伯爵》");
    }
}
public class XiaoWang extends LaoWang {
    @Override
    public void write() {
        System.out.println("小王寫了一本《茶花女》");
    }
}

重寫的兩個方法名相同，方法引數的個數也相同；不過一個方法在父類中，另外一個在子類中。就好像父類 LaoWang 有一個 write() 方法（無參），方法體是寫一本《基督山伯爵》；子類 XiaoWang 重寫了父類的 write() 方法（無參），但方法體是寫一本《茶花女》。

來寫一段測試程式碼。

public class OverridingTest {
    public static void main(String[] args) {
        LaoWang wang = new XiaoWang();
        wang.write();
    }
}

大家猜結果是什麼？

小王寫了一本《茶花女》

在上面的程式碼中，們宣告瞭一個型別為 LaoWang 的變數 wang。在編譯期間，編譯器會檢查 LaoWang 類是否包含了 write() 方法，發現 LaoWang 類有，於是編譯通過。在執行期間，new 了一個 XiaoWang 物件，並將其賦值給 wang，此時 Java 虛擬機器知道 wang 引用的是 XiaoWang 物件，所以呼叫的是子類 XiaoWang 中的 write() 方法而不是父類 LaoWang 中的 write() 方法，因此輸出結果為“小王寫了一本《茶花女》”。

再來看一段過載的程式碼吧。

class LaoWang{
    public void read() {
        System.out.println("老王讀了一本《Web全棧開發進階之路》");
    }

    public void read(String bookname) {
        System.out.println("老王讀了一本《" + bookname + "》");
    }
}

過載的兩個方法名相同，但方法引數的個數不同，另外也不涉及到繼承，兩個方法在同一個類中。就好像類 LaoWang 有兩個方法，名字都是 read()，但一個有引數（書名），另外一個沒有（只能讀寫死的一本書）。

來寫一段測試程式碼。

public class OverloadingTest {
    public static void main(String[] args) {
        LaoWang wang = new LaoWang();
        wang.read();
        wang.read("金瓶");
    }
}

這結果就不用猜了。變數 wang 的型別為 LaoWang，wang.read() 呼叫的是無參的 read() 方法，因此先輸出“老王讀了一本《Web全棧開發進階之路》”；wang.read("金瓶") 呼叫的是有參的 read(bookname) 方法，因此後輸出“老王讀了一本《金瓶》”。在編譯期間，編譯器就知道這兩個 read() 方法時不同的，因為它們的方法簽名（=方法名稱+方法引數）不同。

簡單的來總結一下：

1）編譯器無法決定呼叫哪個重寫的方法，因為只從變數的型別上是無法做出判斷的，要在執行時才能決定；但編譯器可以明確地知道該呼叫哪個過載的方法，因為引用型別是確定的，引數個數決定了該呼叫哪個方法。

2）多型針對的是重寫，而不是過載。

• 如果在一個類中有多個相同名字的方法，但引數不同，則稱為方法過載。

• 父類中有一個方法，子類中有另外一個和它有相同簽名（方法名相同，引數相同、修飾符相同）的方法時，則稱為方法重寫。子類在重寫父類方法的時候可以加一個 @Override 註解。

19、`main()` 方法可以過載嗎？

可以，一個類中可以有多個名稱為“main”的方法：

public class MainTest {
    public static void main(String[] args) {
        System.out.println("main(String[] args)");
    }

    public static void main(String[] args,String arg) {
        System.out.println("(String[] args,String arg");
    }
}

但該類在執行的時候，只會找到一個入口，即 public static void main(String[] args)。

20、一個 Java 原始檔中有多個 public 類嗎？

一個 Java 原始檔中不能有多個 public 類。

21、什麼是 Java 的 package（包）？

在 Java 中，我們使用 package（包）對相關的類、介面和子包進行分組。這樣做的好處有：

• 使相關型別更容易查詢
• 避免命名衝突，比如說 com.itwanger.Hello 和 com.itwangsan.Hello 不同
• 通過包和訪問許可權控制符來限定類的可見性

可以使用 package 關鍵字來定義一個包名，需要注意的是，這行程式碼必須處於一個類中的第一行。強烈建議在包中宣告類，不要預設，否則就失去了包結構的帶來的好處。

包的命名應該遵守以下規則：

• 應該全部是小寫字母
• 可以包含多個單詞，單詞之間使用“.”連線，比如說 java.lang
• 名稱由公司名或者組織名確定，採用倒序的方式，比如說，我個人部落格的域名是 www.itwanger.com，所以我建立的包名是就是 com.itwanger.xxxx。

每個包或者子包都在磁碟上有自己的目錄結構，如果 Java 檔案時在 com.itwanger.xxxx 包下，那麼該檔案所在的目錄結構就應該是 com->itwanger->xxxx。

預設情況下，java.lang 包是預設匯入的，我們不需要顯式地匯入該包下的任何類。

package com.cmower.bb;

public class PackageTest {
    public static void main(String[] args) {
        Boolean.toString(true);
    }
}

Boolean 類屬於 java.lang 包，當使用它的時候並不需要顯式匯入。

22、什麼是訪問許可權修飾符？

訪問許可權修飾符對於 Java 來說，非常重要，目前共有四種：public、private、protected 和 default（預設）。

一個類只能使用 public 或者 default 修飾，public 修飾的類你之前已經見到過了，現在我來定義一個預設許可權修飾符的類給你欣賞一下。

class Dog {
}

哈哈，其實也沒啥可以欣賞的。預設意味著這個類可以被同一個包下的其他類進行訪問；而 public 意味著這個類可以被所有包下的類進行訪問。

假如硬要通過 private 和 protected 來修飾類的話，編譯器會生氣的，它不同意。

private 可以用來修飾類的構造方法、欄位和方法，只能被當前類進行訪問。protected 也可以用來修飾類的構造方法、欄位和方法，但它的許可權範圍更寬一些，可以被同一個包中的類進行訪問，或者當前類的子類。

可以通過下面這張圖來對比一下四個許可權修飾符之間的差別：

• 同一個類中，不管是哪種許可權修飾符，都可以訪問；
• 同一個包下，private 修飾的無法訪問；
• 子類可以訪問 public 和 protected 修飾的；
• public 修飾符面向世界，哈哈，可以被所有的地方訪問到。

23、什麼是 final 關鍵字？

final 關鍵字修飾類的時候，表示該類無法被繼承。比如，String 類就是 final 的，無法被繼承。

final 關鍵字修飾方法的時候，表示子類無法覆蓋它。

final 關鍵字修飾變數的時候，表示該變數只能被賦值一次，儘管變數的狀態可以更改。

關於 final 更詳細的內容，可以參照我之前寫了另外一篇文章：

我去，你竟然還不會用 final 關鍵字

24、什麼是 static 關鍵字？

static 關鍵字可以用來修飾類變數，使其具有全域性性，即所有物件將共享同一個變數。

static 關鍵字可以用來修飾方法，該方法稱為靜態方法，只可以訪問類的靜態變數，並且只能呼叫類的靜態方法。

關於 static 更詳細的內容，可以參照我之前寫了另外一篇文章：

面試官：兄弟，說說Java的static關鍵字吧

25、finally 和 finalize 有什麼區別？

finally 通常與 try-catch 塊一起使用，即使 try-catch 塊引發了異常，finally 塊中的程式碼也會被執行，用於釋放 try 塊中建立的資源。

finalize() 是 Object 類的一個特殊方法，當物件正在被垃圾回收時，垃圾收集器將會呼叫該方法。可以重寫該方法用於釋放系統資源。

26、可以將一個類宣告為 static 的嗎？

不能將一個外部類宣告為 static 的，但可以將一個內部類宣告為 static 的——稱為靜態內部類。

27、什麼是靜態匯入？

如果必須在一個類中使用其他類的靜態變數或者靜態方法，通常我們需要先匯入該類，然後使用“類名.變數/方法”的形式呼叫。

import java.lang.Math;

double test = Math.PI * 5;

也可以通過靜態匯入的方式，就不需要再使用類名了。

import static java.lang.Math.PI;

double test = PI * 5;

不過，靜態匯入容易引發混亂（變數名或者方法名容易衝突），因此最好避免使用靜態匯入。

28、什麼是 try-with-resources？

try-with-resources 是 Java 7 時引入的一個自動資源管理語句，在此之前，我們必須通過 try-catch-finally 的方式手動關閉資源，當我們忘記關閉資源的時候，就容易導致記憶體洩漏。

關於 try-with-resources 更詳細的內容，可以參照我之前寫了另外一篇文章：

我去，你竟然還在用 try–catch-finally

29、什麼是 multi-catch？

Java 7 改進的另外一個地方就是 multi-catch，可以在單個 catch 中捕獲多個異常，當一個 try 塊丟擲多個類似的異常時，這種寫法更短，更清晰。

catch(IOException | SQLException ex){
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

當有多個異常的時候，可以使用管道表示符“|”隔開。

30、什麼是 static 塊？

static 塊是由 Java ClassLoader 將類載入到記憶體中時執行的程式碼塊。通常用於初始化類的靜態變數或者建立靜態資源。

31、什麼是介面？

介面是 Java 程式語言中的一個核心概念，不僅在 JDK 原始碼中使用很多，還在 Java 設計模式、框架和工具中使用很多。介面提供了一種在 Java 中實現抽象的方法，用於定義子類的行為約定。

關於介面更詳細的內容，可以參照我之前寫了另外一篇文章：

可能是把 Java 介面講得最通俗的一篇文章

32、什麼是抽象類？

在 Java 中，抽象類用於建立具有某些被子類實現的預設方法的類，一個抽象類可以有沒有方法體的抽象方法，也可以有和普通類一樣有方法體的方法。

abstract 關鍵字用於宣告一個抽象類，抽象類無法例項化，主要用於為子類提供一個模板，子類需要覆蓋抽象方法。

關於抽象類更詳細的內容，可以參照我之前寫了另外一篇文章：

小白，你要的Java抽象類，操碎了心

33、抽象類和介面有什麼區別？

• 宣告抽象類的關鍵字為 abstract，宣告介面的關鍵字為 interface。
• 抽象類可以有具體的方法，介面不能。
• 一個類只能繼承一個抽象類，但可以實現多個介面。
• 介面中的變數只能是隱式的常量，抽象類中可以有任意型別的變數。
• 如果一個抽象類有 main() 方法，則可以執行它；但介面不能。
• 抽象類是對類的一種抽象，繼承抽象類的類和抽象類本身是一種 is-a 的關係。
• 介面是對類的某種行為的一種抽象，介面和類之間並沒有很強的關聯關係，所有的類都可以實現 Serializable 介面，從而具有序列化的功能。

34、一個介面可以實現或者繼承另外一個介面嗎？

介面不能實現另外一個介面，但可以繼承一個介面。

因為介面中不能有具體的方法，所以不會出現菱形問題，所以我們可以在一個介面中繼承多個介面。

public interface C extends A,B{
}

從 Java 8 開始，介面可以有預設方法，所以當多個介面中存在相同的預設方法時，需要在實現介面的類中提供該方法的實現。

35、什麼是標記介面？

標記介面是一個空的介面，沒有任何方法，用於強制實現類中的某些功能。比較出名的標記介面有 Serializable 介面、Cloneable 介面。

關於 Serializable 介面更詳細的內容，可以參照我之前寫了另外一篇文章：

Java Serializable：明明就一個空的介面嘛

36、什麼是包裝器類？

包裝器類是 Java 中八種基本資料型別的物件表示形式，所有的包裝器類都是不可變的，並且是 final 的。通過裝箱和拆箱，可以將八種基本資料型別和包裝器型別互相轉換。

關於基本型別和包裝型別更詳細的內容，可以參照我之前寫了另外一篇文章：

面試官：兄弟，說說基本型別和包裝型別的區別吧

37、什麼是列舉？

enum（列舉）是 Java 1.5 時引入的關鍵字，它表示一種特殊型別的類，預設繼承自 java.lang.Enum。

public enum PlayerType {
    TENNIS,
    FOOTBALL,
    BASKETBALL
}

enum 是用於建立列舉的關鍵字，列舉中的常量都是隱式 static 和 final 的。

關於列舉更詳細的內容，可以參照我之前寫了另外一篇文章：

恕我直言，我懷疑你並不會用 Java 列舉

38、什麼是 Java 註解？

註解是 Java 1.5 時引入的，同 class 和 interface 一樣，也屬於一種型別，註解提供了一系列資料用來裝飾程式程式碼（類、方法、欄位等），但是註解並不是所裝飾程式碼的一部分，它對程式碼的執行效果沒有直接影響（這句話怎麼理解呢？），由編譯器決定該執行哪些操作。

關於註解更詳細的內容，可以參照我之前寫了另外一篇文章：

不吹牛逼，擼個註解有什麼難的

39、什麼是 Java 反射？

Java 反射機制是在執行狀態中，對於任意一個類，都能夠知道這個類的所有欄位和方法；對於任意一個物件，都能夠呼叫它的任意欄位和方法；這種動態獲取資訊以及動態呼叫物件方法的功能稱為 Java 反射機制。

反射屬於高階主題，在常規程式設計中應該避免使用，因為反射可以通過呼叫私有的構造方法來破壞設計模式，比如說單例模式。

儘管不建議使用反射機制，但反射機制的存在至關重要，因為如果沒有反射，我們將沒有 Spring 之類的框架，甚至 Tomcat 之類的伺服器。它們通過反射呼叫適當的方法並對類例項化，省去了很多麻煩。

40、Java 中的組合指的什麼？

通過物件組合可以實現程式碼的重用，Java 組合是通過引用其他物件的引用來實現的，使用組合的好處就是我們可以控制其他物件對使用者的可見性，並且刻意重用我們需要的物件。

41、與繼承相比，組合有什麼好處？

• 任何父類的修改都可能會影響到子類，甚至我們沒有使用父類的一些方法。舉個例子，假如子類有一個方法 test()，而父類之前是沒有的，但突然有人在不知情的情況下在父類插入了一個同名但簽名不同的 test() 方法，那麼就會出現編譯錯誤。組合是不會遇到這個問題的，因為我們僅僅會使用我們需要的方法。

這是父類追加的 test() 方法：

public class Super {
    public String test() {
        System.out.println("super");
        return null;
    }
}

原來子類的 test() 方法就出錯了。

來個表格列舉一下兩者之間的優缺點：

組 合 關 系	繼 承 關 系
優點：不破壞封裝，整體類與區域性類之間鬆耦合，彼此相對獨立	缺點：破壞封裝，子類與父類之間緊密耦合，子類依賴於父類的實現，子類缺乏獨立性
優點：具有較好的可擴充套件性	缺點：支援擴充套件，但是往往以增加系統結構的複雜度為代價
優點：支援動態組合。在執行時，整體物件可以選擇不同型別的區域性物件	缺點：不支援動態繼承。在執行時，子類無法選擇不同的父類
優點：整體類可以對區域性類進行包裝，封裝區域性類的介面，提供新的介面	缺點：子類不能改變父類的介面
缺點：整體類不能自動獲得和區域性類同樣的介面	優點：子類能自動繼承父類的介面
缺點：建立整體類的物件時，需要建立所有區域性類的物件	優點：建立子類的物件時，無須建立父類的物件

42、如何在 Java 中對自定義物件的集合進行排序？

需要對自定義物件的類實現 Comparable 介面，重寫 compareTo(T obj) 方法，該方法在排序的時候會被呼叫進行排序。

關於 Comparable 和 Comparator 介面更詳細的內容，可以參照我之前寫了另外一篇文章：

一文徹底搞懂Java中的Comparable和Comparator

43、什麼是內部類？

我們可以在一個類中定義一個類，這個類被稱為內部類。內部類可以訪問外部類的所有變數和方法，內部類中不能有任何靜態變數。

44、什麼是匿名內部類？

沒有名稱的內部類稱為匿名內部類，它通過單個語句進行定義和例項化，總是需要擴充套件一個類或者實現一個介面。

由於匿名內部類沒有名稱，所以無法為匿名內部類定義構造方法。

45、什麼是 Java 中的 Classloader（類載入器）？

當我們要訪問任何類時，都需要通過 Java Classloader 將該類的位元組碼加在到記憶體當中，可以通過繼承 ClassLoader 並重寫 loadClass(String name) 方法來建立自定義的類載入器。

46、有哪些不同的類載入器？

• Bootstrap 類載入器，用來加在 JDK 的內部類，比如說 rt.jar。

• Extensions 類載入器，它從 JDK 擴充套件目錄（JAVA_HOME/lib/ext）中載入類。

• System 類載入器，它從當前類路徑載入類。

47、什麼是三元運算子？

三元運算子是 if-then-else 語句的一個替換，示例如下：

result = testStatement ? value1 : value2;

48、super 關鍵字有什麼用？

當在子類中重寫了父類方法時，可以通過 super 關鍵字訪問父類方法。

也可以使用 super 關鍵字在子類構造方法中呼叫父類構造方法，它必須是構造方法中的第一條語句。

public class SuperClass {

    public SuperClass(){
    }

    public SuperClass(int i){}

    public void test(){
        System.out.println("父類的測試方法");
    }
}

來看子類中如何使用 super 關鍵字：

public class ChildClass extends SuperClass {

    public ChildClass(String str){
        // 呼叫父類的構造方法
        super();

        // 呼叫子類的 test 方法
        test();

        // 使用 super 關鍵字呼叫父類的 test 方法
        super.test();
    }

    @Override
    public void test(){
        System.out.println("child class test method");
    }
}

49、什麼是 break，什麼是 continue？

我們可以使用 break 關鍵字終止 for、while、do-while 迴圈；可以在 switch 語句中使用 break 退出 case 條件。

我們可以使用 continue 關鍵字在 for、while、do-while 迴圈跳過當前迭代；甚至可以使用帶有標籤的 continue 語句來跳過最外層迴圈的當前迭代。

50、什麼是 this 關鍵字？

this 關鍵字提供對當前物件的引用，主要用於確保使用了當前物件的變數，而不是具有相同名稱的區域性變數。

//constructor
public Point(int x, int y) {
    this.x = x;
    this.y = y;
}

還可以使用 this 關鍵字在構造方法中呼叫其他構造方法：

public Rectangle() {
    this(0, 0, 0, 0);
}
public Rectangle(int width, int height) {
    this(0, 0, width, height);
}
public Rectangle(int x, int y, int width, int height) {
    this.x = x;
    this.y = y;
    this.width = width;
    this.height = height;
}

關於 this 關鍵字更詳細的內容，可以參照我之前寫了另外一篇文章：

我去，你竟然還不會用 this 關鍵字

51、什麼是預設的構造方法？

一個類的無參構造方法被稱為預設構造方法。當我們沒有為一個類定義構造方法時，Java 編譯器會自動為該類建立一個預設的無參構造方法。如果定義了其他構造方法，編譯器就不會在為我們建立預設構造方法了。

52、try 塊可以沒有 catch 嗎？

是的，可以直接使用 try-finally，而不需要 catch 捕獲異常。

53、什麼是垃圾回收？

垃圾回收（Garbage Collection，簡稱 GC）會檢視堆記憶體，識別正在使用和未使用的物件，以及會自動刪除未使用的物件，用來釋放記憶體。

54、什麼是序列化和反序列化？

我們可以把一個 Java 物件轉化成一個資料流，這被稱為序列化。一旦物件被轉化為資料流後，就可以將其儲存到檔案或者通過網路套接字傳送。

如果一個物件實現了 Serializable 介面，就可以使用 java.io.ObjectOutputStream 將物件寫入檔案。

將資料流再轉化為 Java 物件被稱為反序列化。

55、如何通過命令提示符執行 jar 檔案？

可以通過 java 命令執行 jar 檔案，但需要 jar 檔案中有 main 方法。

56、System 類有什麼用？

System 類是 Java 的一個核心類，比較常用的就是 System.out.println()。

System 類是 final 的，因此我們不能通過繼承來重寫它的方法，System 類沒有提供任何 public 的構造方法，因此無法例項化，它的所有方法都是 static 的。

57、什麼是 instanceof 關鍵字？

我們可以使用 instanceof 關鍵字檢查物件是否屬於一個類。

public static void main(String args[]){
    Object str = new String("沉默王二");

    if(str instanceof String){
        System.out.println("字串值為：" + str);
    }

    if(str instanceof Integer){
        System.out.println("數字的值是：" + str);
    }
}

58、可以在 switch 中使用字串嗎？

Java 7 改進的一個功能就是允許在 switch 語句中使用字串。

關於 switch 更詳細的內容，可以參照我之前寫了另外一篇文章：

我去，你寫的 switch 語句也太老土了吧

59、Java 是按值傳遞還是按引用傳遞？

可以很確定地說，Java 是按值傳遞的。

關於這個問題，可以參照我之前寫了另外一篇文章：

面試官：兄弟，說說Java到底是值傳遞還是引用傳遞

60、堆（heap）和棧（stack）有什麼區別？

• 堆記憶體被應用程式的所有部分使用，而棧記憶體僅由執行執行緒使用。
• 當我們建立物件時，它始終儲存在堆空間上；棧僅儲存該物件的引用，棧記憶體還可以儲存區域性的基本型別資料變數。
• 棧的記憶體管理方式是 LIFO（後進先出）形式，而堆的記憶體管理方式更復雜。

61、Java 編譯在 JDK 中，還是 JRE，還是 JVM 中？

Java 編譯器的任務是將 Java 原始碼轉換為位元組碼，可以通過 javac 命令執行，因此它在 JDK 中，JRE 中不需要它。

62、下面這段程式輸出什麼？

public class Test {

    public static String toString(){
        System.out.println("測試 toString 方法有沒有被呼叫");
        return "";
    }

    public static void main(String args[]){
        System.out.println(toString());
    }
}

這段程式碼無法編譯通過，因為 java.lang.Object 中的 toString() 方法不是 static 的，它無法被 static 修飾的方法重寫。

那下面這段程式碼呢？

public class Test {
    public static String foo(){
        System.out.println("測試 foo 方法有沒有被呼叫");
        return "";
    }

    public static void main(String args[]){
        Test obj = null;
        System.out.println(obj.foo());
    }
}

這段程式碼會輸出 測試 foo 方法有沒有被呼叫，沒有出現 NullPointerException。為什麼呢？

命名 obj 為 null 啊，通過 obj 呼叫 foo() 方法的時候應該丟擲 NullPointerException 異常才對啊！

之所以沒有丟擲異常，是因為 Java 編譯器對這段程式碼做出了優化，因為 foo() 方法是靜態方法，所以 obj.foo() 會被優化為 foo()，所以就不會丟擲異常了。

來看一下這段程式碼的位元組碼就明白了：

public class Test {
    public Test() {
    }

    public static String foo() {
        System.out.println("測試 foo 方法有沒有被呼叫");
        return "";
    }

    public static void main(String[] args) {
        Test obj = null;
        System.out.println(foo());
    }
}

鳴謝

說句實在話，這 62 道 Java 核心面試題在面試的過程中還是很常見的，值得好好複習一遍。

好了，我親愛的小夥伴們，能看到這裡絕逼是最優秀的程式設計師，二哥必須伸出帥氣的大拇指為你點個贊！

---

我是沉默王二，一枚有顏值卻靠才華苟且的程式設計師。關注即可提升學習效率，別忘了三連啊，點贊、收藏、留言，我不挑，奧利給。

注：如果文章有任何問題，歡迎毫不留情地指正。

很多讀者都同情我說，“二哥母豬似的日更原創累不累？”我只能說寫作不易，且行且珍惜啊，歡迎微信搜尋「沉默王二」第一時間閱讀，回覆「簡歷」更有我精心為你準備的簡歷模板，本文 GitHub github.com/itwanger 已收錄，歡迎 star。