2.7w字！Java基礎面試題/知識點總結！（2021 最新版）

這篇《Java 基礎知識總結》是 JavaGuide 上閱讀量最高的一篇文章，由於我對其進行了重構完善並且修復了很多小問題，所以，在博客園再同步一下！

文章內容比較多，目錄如下：

基礎概念與常識

Java 語言有哪些特點?

簡單易學；
面向對象（封裝，繼承，多態）；
平臺無關性（ Java 虛擬機實現平臺無關性）；
支持多線程（ C++ 語言沒有內置的多線程機制，因此必須調用操作系統的多線程功能來進行多線程程序設計，而 Java 語言卻提供了多線程支持）；
可靠性；
安全性；
支持網絡編程並且很方便（ Java 語言誕生本身就是爲簡化網絡編程設計的，因此 Java 語言不僅支持網絡編程而且很方便）；
編譯與解釋並存；

修正（參見： issue#544）：C++11 開始（2011 年的時候）,C++就引入了多線程庫，在 windows、linux、macos 都可以使用std::thread和std::async來創建線程。參考鏈接：http://www.cplusplus.com/reference/thread/thread/?kw=thread

JVM vs JDK vs JRE

JVM

Java 虛擬機（JVM）是運行 Java 字節碼的虛擬機。JVM 有針對不同系統的特定實現（Windows，Linux，macOS），目的是使用相同的字節碼，它們都會給出相同的結果。

什麼是字節碼?採用字節碼的好處是什麼?

在 Java 中，JVM 可以理解的代碼就叫做字節碼（即擴展名爲 .class 的文件），它不面向任何特定的處理器，只面向虛擬機。Java 語言通過字節碼的方式，在一定程度上解決了傳統解釋型語言執行效率低的問題，同時又保留了解釋型語言可移植的特點。所以 Java 程序運行時比較高效，而且，由於字節碼並不針對一種特定的機器，因此，Java 程序無須重新編譯便可在多種不同操作系統的計算機上運行。

Java 程序從源代碼到運行一般有下面 3 步：

我們需要格外注意的是 .class->機器碼這一步。在這一步 JVM 類加載器首先加載字節碼文件，然後通過解釋器逐行解釋執行，這種方式的執行速度會相對比較慢。而且，有些方法和代碼塊是經常需要被調用的(也就是所謂的熱點代碼)，所以後面引進了 JIT 編譯器，而 JIT 屬於運行時編譯。當 JIT 編譯器完成第一次編譯後，其會將字節碼對應的機器碼保存下來，下次可以直接使用。而我們知道，機器碼的運行效率肯定是高於 Java 解釋器的。這也解釋了我們爲什麼經常會說 Java 是編譯與解釋共存的語言。

HotSpot 採用了惰性評估(Lazy Evaluation)的做法，根據二八定律，消耗大部分系統資源的只有那一小部分的代碼（熱點代碼），而這也就是 JIT 所需要編譯的部分。JVM 會根據代碼每次被執行的情況收集信息並相應地做出一些優化，因此執行的次數越多，它的速度就越快。JDK 9 引入了一種新的編譯模式 AOT(Ahead of Time Compilation)，它是直接將字節碼編譯成機器碼，這樣就避免了 JIT 預熱等各方面的開銷。JDK 支持分層編譯和 AOT 協作使用。但是，AOT 編譯器的編譯質量是肯定比不上 JIT 編譯器的。

總結：

Java 虛擬機（JVM）是運行 Java 字節碼的虛擬機。JVM 有針對不同系統的特定實現（Windows，Linux，macOS），目的是使用相同的字節碼，它們都會給出相同的結果。字節碼和不同系統的 JVM 實現是 Java 語言“一次編譯，隨處可以運行”的關鍵所在。

JDK 和 JRE

JDK 是 Java Development Kit 縮寫，它是功能齊全的 Java SDK。它擁有 JRE 所擁有的一切，還有編譯器（javac）和工具（如 javadoc 和 jdb）。它能夠創建和編譯程序。

JRE 是 Java 運行時環境。它是運行已編譯 Java 程序所需的所有內容的集合，包括 Java 虛擬機（JVM），Java 類庫，java 命令和其他的一些基礎構件。但是，它不能用於創建新程序。

如果你只是爲了運行一下 Java 程序的話，那麼你只需要安裝 JRE 就可以了。如果你需要進行一些 Java 編程方面的工作，那麼你就需要安裝 JDK 了。但是，這不是絕對的。有時，即使您不打算在計算機上進行任何 Java 開發，仍然需要安裝 JDK。例如，如果要使用 JSP 部署 Web 應用程序，那麼從技術上講，您只是在應用程序服務器中運行 Java 程序。那你爲什麼需要 JDK 呢？因爲應用程序服務器會將 JSP 轉換爲 Java servlet，並且需要使用 JDK 來編譯 servlet。

爲什麼說 Java 語言“編譯與解釋並存”？

高級編程語言按照程序的執行方式分爲編譯型和解釋型兩種。簡單來說，編譯型語言是指編譯器針對特定的操作系統將源代碼一次性翻譯成可被該平臺執行的機器碼；解釋型語言是指解釋器對源程序逐行解釋成特定平臺的機器碼並立即執行。比如，你想閱讀一本英文名著，你可以找一個英文翻譯人員幫助你閱讀，
有兩種選擇方式，你可以先等翻譯人員將全本的英文名著（也就是源碼）都翻譯成漢語，再去閱讀，也可以讓翻譯人員翻譯一段，你在旁邊閱讀一段，慢慢把書讀完。

Java 語言既具有編譯型語言的特徵，也具有解釋型語言的特徵，因爲 Java 程序要經過先編譯，後解釋兩個步驟，由 Java 編寫的程序需要先經過編譯步驟，生成字節碼（\*.class 文件），這種字節碼必須由 Java 解釋器來解釋執行。因此，我們可以認爲 Java 語言編譯與解釋並存。

Oracle JDK 和 OpenJDK 的對比

可能在看這個問題之前很多人和我一樣並沒有接觸和使用過 OpenJDK 。那麼 Oracle 和 OpenJDK 之間是否存在重大差異？下面我通過收集到的一些資料，爲你解答這個被很多人忽視的問題。

對於 Java 7，沒什麼關鍵的地方。OpenJDK 項目主要基於 Sun 捐贈的 HotSpot 源代碼。此外，OpenJDK 被選爲 Java 7 的參考實現，由 Oracle 工程師維護。關於 JVM，JDK，JRE 和 OpenJDK 之間的區別，Oracle 博客帖子在 2012 年有一個更詳細的答案：

問：OpenJDK 存儲庫中的源代碼與用於構建 Oracle JDK 的代碼之間有什麼區別？

答：非常接近 - 我們的 Oracle JDK 版本構建過程基於 OpenJDK 7 構建，只添加了幾個部分，例如部署代碼，其中包括 Oracle 的 Java 插件和 Java WebStart 的實現，以及一些封閉的源代碼派對組件，如圖形光柵化器，一些開源的第三方組件，如 Rhino，以及一些零碎的東西，如附加文檔或第三方字體。展望未來，我們的目的是開源 Oracle JDK 的所有部分，除了我們考慮商業功能的部分。

總結：

Oracle JDK 大概每 6 個月發一次主要版本，而 OpenJDK 版本大概每三個月發佈一次。但這不是固定的，我覺得了解這個沒啥用處。詳情參見：https://blogs.oracle.com/java-platform-group/update-and-faq-on-the-java-se-release-cadence 。
OpenJDK 是一個參考模型並且是完全開源的，而 Oracle JDK 是 OpenJDK 的一個實現，並不是完全開源的；
Oracle JDK 比 OpenJDK 更穩定。OpenJDK 和 Oracle JDK 的代碼幾乎相同，但 Oracle JDK 有更多的類和一些錯誤修復。因此，如果您想開發企業/商業軟件，我建議您選擇 Oracle JDK，因爲它經過了徹底的測試和穩定。某些情況下，有些人提到在使用 OpenJDK 可能會遇到了許多應用程序崩潰的問題，但是，只需切換到 Oracle JDK 就可以解決問題；
在響應性和 JVM 性能方面，Oracle JDK 與 OpenJDK 相比提供了更好的性能；
Oracle JDK 不會爲即將發佈的版本提供長期支持，用戶每次都必須通過更新到最新版本獲得支持來獲取最新版本；
Oracle JDK 使用 BCL/OTN 協議獲得許可，而 OpenJDK 根據 GPL v2 許可獲得許可。

🌈 拓展一下：

BCL 協議（Oracle Binary Code License Agreement）：可以使用JDK（支持商用），但是不能進行修改。
OTN 協議（Oracle Technology Network License Agreement）： 11 及之後新發布的JDK用的都是這個協議，可以自己私下用，但是商用需要付費。

Java 和 C++的區別?

我知道很多人沒學過 C++，但是面試官就是沒事喜歡拿咱們 Java 和 C++ 比呀！沒辦法！！！就算沒學過 C++，也要記下來！

都是面向對象的語言，都支持封裝、繼承和多態
Java 不提供指針來直接訪問內存，程序內存更加安全
Java 的類是單繼承的，C++ 支持多重繼承；雖然 Java 的類不可以多繼承，但是接口可以多繼承。
Java 有自動內存管理垃圾回收機制(GC)，不需要程序員手動釋放無用內存。
C ++同時支持方法重載和操作符重載，但是 Java 只支持方法重載（操作符重載增加了複雜性，這與 Java 最初的設計思想不符）。
......

import java 和 javax 有什麼區別？

剛開始的時候 JavaAPI 所必需的包是 java 開頭的包，javax 當時只是擴展 API 包來使用。然而隨着時間的推移，javax 逐漸地擴展成爲 Java API 的組成部分。但是，將擴展從 javax 包移動到 java 包確實太麻煩了，最終會破壞一堆現有的代碼。因此，最終決定 javax 包將成爲標準 API 的一部分。

所以，實際上 java 和 javax 沒有區別。這都是一個名字。

基本語法

字符型常量和字符串常量的區別?

形式 : 字符常量是單引號引起的一個字符，字符串常量是雙引號引起的 0 個或若干個字符
含義 : 字符常量相當於一個整型值( ASCII 值),可以參加表達式運算; 字符串常量代表一個地址值(該字符串在內存中存放位置)
佔內存大小 ：字符常量只佔 2 個字節; 字符串常量佔若干個字節 (注意： char 在 Java 中佔兩個字節),

字符封裝類 Character 有一個成員常量 Character.SIZE 值爲 16,單位是bits,該值除以 8(1byte=8bits)後就可以得到 2 個字節

java 編程思想第四版：2.2.2 節

註釋

Java 中的註釋有三種：

單行註釋
多行註釋
文檔註釋。

在我們編寫代碼的時候，如果代碼量比較少，我們自己或者團隊其他成員還可以很輕易地看懂代碼，但是當項目結構一旦複雜起來，我們就需要用到註釋了。註釋並不會執行(編譯器在編譯代碼之前會把代碼中的所有註釋抹掉,字節碼中不保留註釋)，是我們程序員寫給自己看的，註釋是你的代碼說明書，能夠幫助看代碼的人快速地理清代碼之間的邏輯關係。因此，在寫程序的時候隨手加上註釋是一個非常好的習慣。

《Clean Code》這本書明確指出：

代碼的註釋不是越詳細越好。實際上好的代碼本身就是註釋，我們要儘量規範和美化自己的代碼來減少不必要的註釋。

若編程語言足夠有表達力，就不需要註釋，儘量通過代碼來闡述。

舉個例子：

去掉下面複雜的註釋，只需要創建一個與註釋所言同一事物的函數即可
// check to see if the employee is eligible for full benefits
if ((employee.flags & HOURLY_FLAG) && (employee.age > 65))
應替換爲
if (employee.isEligibleForFullBenefits())

標識符和關鍵字的區別是什麼？

在我們編寫程序的時候，需要大量地爲程序、類、變量、方法等取名字，於是就有了標識符，簡單來說，標識符就是一個名字。但是有一些標識符，Java 語言已經賦予了其特殊的含義，只能用於特定的地方，這種特殊的標識符就是關鍵字。因此，關鍵字是被賦予特殊含義的標識符。比如，在我們的日常生活中，“警察局”這個名字已經被賦予了特殊的含義，所以如果你開一家店，店的名字不能叫“警察局”，“警察局”就是我們日常生活中的關鍵字。

Java 中有哪些常見的關鍵字？

訪問控制	private	protected	public
類，方法和變量修飾符	abstract	class	extends	final	implements	interface	native
	new	static	strictfp	synchronized	transient	volatile
程序控制	break	continue	return	do	while	if	else
	for	instanceof	switch	case	default
錯誤處理	try	catch	throw	throws	finally
包相關	import	package
基本類型	boolean	byte	char	double	float	int	long
	short	null	true	false
變量引用	super	this	void
保留字	goto	const

自增自減運算符

在寫代碼的過程中，常見的一種情況是需要某個整數類型變量增加 1 或減少 1，Java 提供了一種特殊的運算符，用於這種表達式，叫做自增運算符（++)和自減運算符（--）。

++和--運算符可以放在變量之前，也可以放在變量之後，當運算符放在變量之前時(前綴)，先自增/減，再賦值；當運算符放在變量之後時(後綴)，先賦值，再自增/減。例如，當 b = ++a 時，先自增（自己增加 1），再賦值（賦值給 b）；當 b = a++ 時，先賦值(賦值給 b)，再自增（自己增加 1）。也就是，++a 輸出的是 a+1 的值，a++輸出的是 a 值。用一句口訣就是：“符號在前就先加/減，符號在後就後加/減”。

continue、break、和 return 的區別是什麼？

在循環結構中，當循環條件不滿足或者循環次數達到要求時，循環會正常結束。但是，有時候可能需要在循環的過程中，當發生了某種條件之後，提前終止循環，這就需要用到下面幾個關鍵詞：

continue ：指跳出當前的這一次循環，繼續下一次循環。
break ：指跳出整個循環體，繼續執行循環下面的語句。

return 用於跳出所在方法，結束該方法的運行。return 一般有兩種用法：

return; ：直接使用 return 結束方法執行，用於沒有返回值函數的方法
return value; ：return 一個特定值，用於有返回值函數的方法

Java 泛型瞭解麼？什麼是類型擦除？介紹一下常用的通配符？

Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制，該機制允許程序員在編譯時檢測到非法的類型。泛型的本質是參數化類型，也就是說所操作的數據類型被指定爲一個參數。

Java 的泛型是僞泛型，這是因爲 Java 在編譯期間，所有的泛型信息都會被擦掉，這也就是通常所說類型擦除。

List<Integer> list = new ArrayList<>();

list.add(12);
//這裏直接添加會報錯
list.add("a");
Class<? extends List> clazz = list.getClass();
Method add = clazz.getDeclaredMethod("add", Object.class);
//但是通過反射添加，是可以的
add.invoke(list, "kl");

System.out.println(list);

泛型一般有三種使用方式:泛型類、泛型接口、泛型方法。

1.泛型類：

//此處T可以隨便寫爲任意標識，常見的如T、E、K、V等形式的參數常用於表示泛型
//在實例化泛型類時，必須指定T的具體類型
public class Generic<T>{

    private T key;

    public Generic(T key) {
        this.key = key;
    }

    public T getKey(){
        return key;
    }
}

如何實例化泛型類：

Generic<Integer> genericInteger = new Generic<Integer>(123456);

2.泛型接口 ：

public interface Generator<T> {
    public T method();
}

實現泛型接口，不指定類型：

class GeneratorImpl<T> implements Generator<T>{
    @Override
    public T method() {
        return null;
    }
}

實現泛型接口，指定類型：

class GeneratorImpl<T> implements Generator<String>{
    @Override
    public String method() {
        return "hello";
    }
}

3.泛型方法 ：

   public static < E > void printArray( E[] inputArray )
   {
         for ( E element : inputArray ){
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }

使用：

// 創建不同類型數組： Integer, Double 和 Character
Integer[] intArray = { 1, 2, 3 };
String[] stringArray = { "Hello", "World" };
printArray( intArray  );
printArray( stringArray  );

常用的通配符爲： T，E，K，V，？

？表示不確定的 java 類型
T (type) 表示具體的一個 java 類型
K V (key value) 分別代表 java 鍵值中的 Key Value
E (element) 代表 Element

==和 equals 的區別

對於基本數據類型來說，比較的是值。對於引用數據類型來說，比較的是對象的內存地址。

因爲 Java 只有值傳遞，所以，對於 == 來說，不管是比較基本數據類型，還是引用數據類型的變量，其本質比較的都是值，只是引用類型變量存的值是對象的地址。

equals() 作用不能用於判斷基本數據類型的變量，只能用來判斷兩個對象是否相等。equals()方法存在於Object類中，而Object類是所有類的直接或間接父類。

Object 類 equals() 方法：

public boolean equals(Object obj) {
     return (this == obj);
}

equals() 方法存在兩種使用情況：

類沒有覆蓋 equals()方法 ：通過equals()比較該類的兩個對象時，等價於通過“==”比較這兩個對象，使用的默認是 Object類equals()方法。
類覆蓋了 equals()方法 ：一般我們都覆蓋 equals()方法來比較兩個對象中的屬性是否相等；若它們的屬性相等，則返回 true(即，認爲這兩個對象相等)。

舉個例子：

public class test1 {
    public static void main(String[] args) {
        String a = new String("ab"); // a 爲一個引用
        String b = new String("ab"); // b爲另一個引用,對象的內容一樣
        String aa = "ab"; // 放在常量池中
        String bb = "ab"; // 從常量池中查找
        if (aa == bb) // true
            System.out.println("aa==bb");
        if (a == b) // false，非同一對象
            System.out.println("a==b");
        if (a.equals(b)) // true
            System.out.println("aEQb");
        if (42 == 42.0) { // true
            System.out.println("true");
        }
    }
}

說明：

String 中的 equals 方法是被重寫過的，因爲 Object 的 equals 方法是比較的對象的內存地址，而 String 的 equals 方法比較的是對象的值。
當創建 String 類型的對象時，虛擬機會在常量池中查找有沒有已經存在的值和要創建的值相同的對象，如果有就把它賦給當前引用。如果沒有就在常量池中重新創建一個 String 對象。

String類equals()方法：

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

hashCode()與 equals()

面試官可能會問你：“你重寫過 hashcode 和 equals麼，爲什麼重寫 equals 時必須重寫 hashCode 方法？”

1)hashCode()介紹:

hashCode() 的作用是獲取哈希碼，也稱爲散列碼；它實際上是返回一個 int 整數。這個哈希碼的作用是確定該對象在哈希表中的索引位置。hashCode()定義在 JDK 的 Object 類中，這就意味着 Java 中的任何類都包含有 hashCode() 函數。另外需要注意的是： Object 的 hashcode 方法是本地方法，也就是用 c 語言或 c++ 實現的，該方法通常用來將對象的內存地址轉換爲整數之後返回。

public native int hashCode();

散列表存儲的是鍵值對(key-value)，它的特點是：能根據“鍵”快速的檢索出對應的“值”。這其中就利用到了散列碼！（可以快速找到所需要的對象）

2)爲什麼要有 hashCode？

我們以“HashSet 如何檢查重複”爲例子來說明爲什麼要有 hashCode？

當你把對象加入 HashSet 時，HashSet 會先計算對象的 hashcode 值來判斷對象加入的位置，同時也會與其他已經加入的對象的 hashcode 值作比較，如果沒有相符的 hashcode，HashSet 會假設對象沒有重複出現。但是如果發現有相同 hashcode 值的對象，這時會調用 equals() 方法來檢查 hashcode 相等的對象是否真的相同。如果兩者相同，HashSet 就不會讓其加入操作成功。如果不同的話，就會重新散列到其他位置。（摘自我的 Java 啓蒙書《Head First Java》第二版）。這樣我們就大大減少了 equals 的次數，相應就大大提高了執行速度。

3)爲什麼重寫 equals 時必須重寫 hashCode 方法？

如果兩個對象相等，則 hashcode 一定也是相同的。兩個對象相等,對兩個對象分別調用 equals 方法都返回 true。但是，兩個對象有相同的 hashcode 值，它們也不一定是相等的。因此，equals 方法被覆蓋過，則 hashCode 方法也必須被覆蓋。

hashCode()的默認行爲是對堆上的對象產生獨特值。如果沒有重寫 hashCode()，則該 class 的兩個對象無論如何都不會相等（即使這兩個對象指向相同的數據）

4)爲什麼兩個對象有相同的 hashcode 值，它們也不一定是相等的？

在這裏解釋一位小夥伴的問題。以下內容摘自《Head Fisrt Java》。

因爲 hashCode() 所使用的雜湊算法也許剛好會讓多個對象傳回相同的雜湊值。越糟糕的雜湊算法越容易碰撞，但這也與數據值域分佈的特性有關（所謂碰撞也就是指的是不同的對象得到相同的 hashCode。

我們剛剛也提到了 HashSet,如果 HashSet 在對比的時候，同樣的 hashcode 有多個對象，它會使用 equals() 來判斷是否真的相同。也就是說 hashcode 只是用來縮小查找成本。

更多關於 hashcode() 和 equals() 的內容可以查看：Java hashCode() 和 equals()的若干問題解答

基本數據類型

Java 中的幾種基本數據類型是什麼？對應的包裝類型是什麼？各自佔用多少字節呢？

Java 中有 8 種基本數據類型，分別爲：

6 種數字類型：byte、short、int、long、float、double
1 種字符類型：char
1 種布爾型：boolean。

這 8 種基本數據類型的默認值以及所佔空間的大小如下：

基本類型	位數	字節	默認值
`int`	32	4	0
`short`	16	2	0
`long`	64	8	0L
`byte`	8	1	0
`char`	16	2	'u0000'
`float`	32	4	0f
`double`	64	8	0d
`boolean`	1		false

另外，對於 boolean，官方文檔未明確定義，它依賴於 JVM 廠商的具體實現。邏輯上理解是佔用 1 位，但是實際中會考慮計算機高效存儲因素。

注意：

Java 裏使用 long 類型的數據一定要在數值後面加上 L，否則將作爲整型解析。
char a = 'h'char :單引號，String a = "hello" :雙引號。

這八種基本類型都有對應的包裝類分別爲：Byte、Short、Integer、Long、Float、Double、Character、Boolean 。

包裝類型不賦值就是 Null ，而基本類型有默認值且不是 Null。

另外，這個問題建議還可以先從 JVM 層面來分析。

基本數據類型直接存放在 Java 虛擬機棧中的局部變量表中，而包裝類型屬於對象類型，我們知道對象實例都存在於堆中。相比於對象類型，基本數據類型佔用的空間非常小。

《深入理解 Java 虛擬機》：局部變量表主要存放了編譯期可知的基本數據類型（boolean、byte、char、short、int、float、long、double）、對象引用（reference 類型，它不同於對象本身，可能是一個指向對象起始地址的引用指針，也可能是指向一個代表對象的句柄或其他與此對象相關的位置）。

自動裝箱與拆箱

裝箱：將基本類型用它們對應的引用類型包裝起來；
拆箱：將包裝類型轉換爲基本數據類型；

舉例：

Integer i = 10;  //裝箱
int n = i;   //拆箱

上面這兩行代碼對應的字節碼爲：

   L1

    LINENUMBER 8 L1

    ALOAD 0

    BIPUSH 10

    INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;

    PUTFIELD AutoBoxTest.i : Ljava/lang/Integer;

   L2

    LINENUMBER 9 L2

    ALOAD 0

    ALOAD 0

    GETFIELD AutoBoxTest.i : Ljava/lang/Integer;

    INVOKEVIRTUAL java/lang/Integer.intValue ()I

    PUTFIELD AutoBoxTest.n : I

    RETURN

從字節碼中，我們發現裝箱其實就是調用了包裝類的valueOf()方法，拆箱其實就是調用了 xxxValue()方法。

因此，

Integer i = 10 等價於 Integer i = Integer.valueOf(10)
int n = i 等價於 int n = i.intValue();

8 種基本類型的包裝類和常量池

Java 基本類型的包裝類的大部分都實現了常量池技術。Byte,Short,Integer,Long 這 4 種包裝類默認創建了數值 [-128，127] 的相應類型的緩存數據，Character 創建了數值在[0,127]範圍的緩存數據，Boolean 直接返回 True Or False。

Integer 緩存源碼：

/**

*此方法將始終緩存-128 到 127（包括端點）範圍內的值，並可以緩存此範圍之外的其他值。

*/

public static Integer valueOf(int i) {

    if (i >= IntegerCache.low && i <= IntegerCache.high)

      return IntegerCache.cache[i + (-IntegerCache.low)];

    return new Integer(i);

}

private static class IntegerCache {

    static final int low = -128;

    static final int high;

    static final Integer cache[];

}

Character 緩存源碼:

public static Character valueOf(char c) {

    if (c <= 127) { // must cache

      return CharacterCache.cache[(int)c];

    }

    return new Character(c);

}



private static class CharacterCache {

    private CharacterCache(){}



    static final Character cache[] = new Character[127 + 1];

    static {

        for (int i = 0; i < cache.length; i++)

            cache[i] = new Character((char)i);

    }

}

Boolean 緩存源碼：

public static Boolean valueOf(boolean b) {

    return (b ? TRUE : FALSE);

}

如果超出對應範圍仍然會去創建新的對象，緩存的範圍區間的大小隻是在性能和資源之間的權衡。

兩種浮點數類型的包裝類 Float,Double 並沒有實現常量池技術。

Integer i1 = 33;

Integer i2 = 33;

System.out.println(i1 == i2);// 輸出 true

Float i11 = 333f;

Float i22 = 333f;

System.out.println(i11 == i22);// 輸出 false

Double i3 = 1.2;

Double i4 = 1.2;

System.out.println(i3 == i4);// 輸出 false

下面我們來看一下問題。下面的代碼的輸出結果是 true 還是 flase 呢？

Integer i1 = 40;

Integer i2 = new Integer(40);

System.out.println(i1==i2);

Integer i1=40 這一行代碼會發生拆箱，也就是說這行代碼等價於 Integer i1=Integer.valueOf(40) 。因此，i1 直接使用的是常量池中的對象。而Integer i1 = new Integer(40) 會直接創建新的對象。

因此，答案是 false 。你答對了嗎？

記住：所有整型包裝類對象之間值的比較，全部使用 equals 方法比較。

方法（函數）

什麼是方法的返回值?

方法的返回值是指我們獲取到的某個方法體中的代碼執行後產生的結果！（前提是該方法可能產生結果）。返回值的作用是接收出結果，使得它可以用於其他的操作！

方法有哪幾種類型？

1.無參數無返回值的方法

// 無參數無返回值的方法(如果方法沒有返回值，不能不寫，必須寫void，表示沒有返回值)
public void f1() {
    System.out.println("無參數無返回值的方法");
}

2.有參數無返回值的方法

/**
* 有參數無返回值的方法
* 參數列表由零組到多組“參數類型+形參名”組合而成，多組參數之間以英文逗號（,）隔開，形參類型和形參名之間以英文空格隔開
*/
public void f2(int a, String b, int c) {
    System.out.println(a + "-->" + b + "-->" + c);
}

3.有返回值無參數的方法

// 有返回值無參數的方法（返回值可以是任意的類型,在函數裏面必須有return關鍵字返回對應的類型）
public int f3() {
    System.out.println("有返回值無參數的方法");
    return 2;
}

4.有返回值有參數的方法

// 有返回值有參數的方法
public int f4(int a, int b) {
    return a * b;
}

5.return 在無返回值方法的特殊使用

// return在無返回值方法的特殊使用
public void f5(int a) {
    if (a > 10) {
        return;//表示結束所在方法 （f5方法）的執行,下方的輸出語句不會執行
    }
    System.out.println(a);
}

在一個靜態方法內調用一個非靜態成員爲什麼是非法的?

這個需要結合 JVM 的相關知識，靜態方法是屬於類的，在類加載的時候就會分配內存，可以通過類名直接訪問。而非靜態成員屬於實例對象，只有在對象實例化之後才存在，然後通過類的實例對象去訪問。在類的非靜態成員不存在的時候靜態成員就已經存在了，此時調用在內存中還不存在的非靜態成員，屬於非法操作。

靜態方法和實例方法有何不同？

在外部調用靜態方法時，可以使用"類名.方法名"的方式，也可以使用"對象名.方法名"的方式。而實例方法只有後面這種方式。也就是說，調用靜態方法可以無需創建對象。
靜態方法在訪問本類的成員時，只允許訪問靜態成員（即靜態成員變量和靜態方法），而不允許訪問實例成員變量和實例方法；實例方法則無此限制。

爲什麼 Java 中只有值傳遞？

首先，我們回顧一下在程序設計語言中有關將參數傳遞給方法（或函數）的一些專業術語。

按值調用(call by value) 表示方法接收的是調用者提供的值，按引用調用（call by reference) 表示方法接收的是調用者提供的變量地址。一個方法可以修改傳遞引用所對應的變量值，而不能修改傳遞值調用所對應的變量值。它用來描述各種程序設計語言（不只是 Java)中方法參數傳遞方式。

Java 程序設計語言總是採用按值調用。也就是說，方法得到的是所有參數值的一個拷貝，也就是說，方法不能修改傳遞給它的任何參數變量的內容。

下面通過 3 個例子來給大家說明

example 1

public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;

    swap(num1, num2);

    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);
}

public static void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;

    System.out.println("a = " + a);
    System.out.println("b = " + b);
}

結果：

a = 20
b = 10
num1 = 10
num2 = 20

解析：

在 swap 方法中，a、b 的值進行交換，並不會影響到 num1、num2。因爲，a、b 中的值，只是從 num1、num2 的複製過來的。也就是說，a、b 相當於 num1、num2 的副本，副本的內容無論怎麼修改，都不會影響到原件本身。

通過上面例子，我們已經知道了一個方法不能修改一個基本數據類型的參數，而對象引用作爲參數就不一樣，請看 example2.

example 2

	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4, 5 };
		System.out.println(arr[0]);
		change(arr);
		System.out.println(arr[0]);
	}

	public static void change(int[] array) {
		// 將數組的第一個元素變爲0
		array[0] = 0;
	}

結果：

1
0

解析：

array 被初始化 arr 的拷貝也就是一個對象的引用，也就是說 array 和 arr 指向的是同一個數組對象。因此，外部對引用對象的改變會反映到所對應的對象上。

通過 example2 我們已經看到，實現一個改變對象參數狀態的方法並不是一件難事。理由很簡單，方法得到的是對象引用的拷貝，對象引用及其他的拷貝同時引用同一個對象。

很多程序設計語言（特別是，C++和 Pascal)提供了兩種參數傳遞的方式：值調用和引用調用。有些程序員（甚至本書的作者）認爲 Java 程序設計語言對對象採用的是引用調用，實際上，這種理解是不對的。由於這種誤解具有一定的普遍性，所以下面給出一個反例來詳細地闡述一下這個問題。

example 3

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student s1 = new Student("小張");
		Student s2 = new Student("小李");
		Test.swap(s1, s2);
		System.out.println("s1:" + s1.getName());
		System.out.println("s2:" + s2.getName());
	}

	public static void swap(Student x, Student y) {
		Student temp = x;
		x = y;
		y = temp;
		System.out.println("x:" + x.getName());
		System.out.println("y:" + y.getName());
	}
}

結果：

x:小李
y:小張
s1:小張
s2:小李

解析：

交換之前：

交換之後：

通過上面兩張圖可以很清晰的看出： 方法並沒有改變存儲在變量 s1 和 s2 中的對象引用。swap 方法的參數 x 和 y 被初始化爲兩個對象引用的拷貝，這個方法交換的是這兩個拷貝

總結

Java 程序設計語言對對象採用的不是引用調用，實際上，對象引用是按
值傳遞的。

下面再總結一下 Java 中方法參數的使用情況：

一個方法不能修改一個基本數據類型的參數（即數值型或布爾型）。
一個方法可以改變一個對象參數的狀態。
一個方法不能讓對象參數引用一個新的對象。

參考：

《Java 核心技術卷 Ⅰ》基礎知識第十版第四章 4.5 小節

重載和重寫的區別

重載就是同樣的一個方法能夠根據輸入數據的不同，做出不同的處理

重寫就是當子類繼承自父類的相同方法，輸入數據一樣，但要做出有別於父類的響應時，你就要覆蓋父類方法

重載

發生在同一個類中（或者父類和子類之間），方法名必須相同，參數類型不同、個數不同、順序不同，方法返回值和訪問修飾符可以不同。

下面是《Java 核心技術》對重載這個概念的介紹：

綜上：重載就是同一個類中多個同名方法根據不同的傳參來執行不同的邏輯處理。

重寫

重寫發生在運行期，是子類對父類的允許訪問的方法的實現過程進行重新編寫。

返回值類型、方法名、參數列表必須相同，拋出的異常範圍小於等於父類，訪問修飾符範圍大於等於父類。
如果父類方法訪問修飾符爲 private/final/static 則子類就不能重寫該方法，但是被 static 修飾的方法能夠被再次聲明。
構造方法無法被重寫

綜上：重寫就是子類對父類方法的重新改造，外部樣子不能改變，內部邏輯可以改變

暖心的 Guide 哥最後再來個圖表總結一下！

區別點	重載方法	重寫方法
發生範圍	同一個類	子類
參數列表	必須修改	一定不能修改
返回類型	可修改	子類方法返回值類型應比父類方法返回值類型更小或相等
異常	可修改	子類方法聲明拋出的異常類應比父類方法聲明拋出的異常類更小或相等；
訪問修飾符	可修改	一定不能做更嚴格的限制（可以降低限制）
發生階段	編譯期	運行期

方法的重寫要遵循“兩同兩小一大”（以下內容摘錄自《瘋狂 Java 講義》,issue#892 ）：

“兩同”即方法名相同、形參列表相同；
“兩小”指的是子類方法返回值類型應比父類方法返回值類型更小或相等，子類方法聲明拋出的異常類應比父類方法聲明拋出的異常類更小或相等；
“一大”指的是子類方法的訪問權限應比父類方法的訪問權限更大或相等。

⭐️ 關於 重寫的返回值類型這裏需要額外多說明一下，上面的表述不太清晰準確：如果方法的返回類型是 void 和基本數據類型，則返回值重寫時不可修改。但是如果方法的返回值是引用類型，重寫時是可以返回該引用類型的子類的。

public class Hero {
    public String name() {
        return "超級英雄";
    }
}
public class SuperMan extends Hero{
    @Override
    public String name() {
        return "超人";
    }
    public Hero hero() {
        return new Hero();
    }
}

public class SuperSuperMan extends SuperMan {
    public String name() {
        return "超級超級英雄";
    }

    @Override
    public SuperMan hero() {
        return new SuperMan();
    }
}

深拷貝 vs 淺拷貝

淺拷貝：對基本數據類型進行值傳遞，對引用數據類型進行引用傳遞般的拷貝，此爲淺拷貝。
深拷貝：對基本數據類型進行值傳遞，對引用數據類型，創建一個新的對象，並複製其內容，此爲深拷貝。

Java 面向對象

面向對象和麪向過程的區別

面向過程 ：面向過程性能比面向對象高。 因爲類調用時需要實例化，開銷比較大，比較消耗資源，所以當性能是最重要的考量因素的時候，比如單片機、嵌入式開發、Linux/Unix 等一般採用面向過程開發。但是，面向過程沒有面向對象易維護、易複用、易擴展。
面向對象 ：面向對象易維護、易複用、易擴展。 因爲面向對象有封裝、繼承、多態性的特性，所以可以設計出低耦合的系統，使系統更加靈活、更加易於維護。但是，面向對象性能比面向過程低。

參見 issue : 面向過程：面向過程性能比面向對象高？？

這個並不是根本原因，面向過程也需要分配內存，計算內存偏移量，Java 性能差的主要原因並不是因爲它是面嚮對象語言，而是 Java 是半編譯語言，最終的執行代碼並不是可以直接被 CPU 執行的二進制機械碼。

而面向過程語言大多都是直接編譯成機械碼在電腦上執行，並且其它一些面向過程的腳本語言性能也並不一定比 Java 好。

成員變量與局部變量的區別有哪些？

從語法形式上看，成員變量是屬於類的，而局部變量是在代碼塊或方法中定義的變量或是方法的參數；成員變量可以被 public,private,static 等修飾符所修飾，而局部變量不能被訪問控制修飾符及 static 所修飾；但是，成員變量和局部變量都能被 final 所修飾。
從變量在內存中的存儲方式來看,如果成員變量是使用 static 修飾的，那麼這個成員變量是屬於類的，如果沒有使用 static 修飾，這個成員變量是屬於實例的。而對象存在於堆內存，局部變量則存在於棧內存。
從變量在內存中的生存時間上看，成員變量是對象的一部分，它隨着對象的創建而存在，而局部變量隨着方法的調用而自動消失。
從變量是否有默認值來看，成員變量如果沒有被賦初，則會自動以類型的默認值而賦值（一種情況例外:被 final 修飾的成員變量也必須顯式地賦值），而局部變量則不會自動賦值。

創建一個對象用什麼運算符?對象實體與對象引用有何不同?

new 運算符，new 創建對象實例（對象實例在堆內存中），對象引用指向對象實例（對象引用存放在棧內存中）。

一個對象引用可以指向 0 個或 1 個對象（一根繩子可以不繫氣球，也可以系一個氣球）;一個對象可以有 n 個引用指向它（可以用 n 條繩子繫住一個氣球）。

對象的相等與指向他們的引用相等,兩者有什麼不同?

對象的相等，比的是內存中存放的內容是否相等。而引用相等，比較的是他們指向的內存地址是否相等。

一個類的構造方法的作用是什麼? 若一個類沒有聲明構造方法，該程序能正確執行嗎? 爲什麼?

構造方法主要作用是完成對類對象的初始化工作。

如果一個類沒有聲明構造方法，也可以執行！因爲一個類即使沒有聲明構造方法也會有默認的不帶參數的構造方法。如果我們自己添加了類的構造方法（無論是否有參），Java 就不會再添加默認的無參數的構造方法了，這時候，就不能直接 new 一個對象而不傳遞參數了，所以我們一直在不知不覺地使用構造方法，這也是爲什麼我們在創建對象的時候後面要加一個括號（因爲要調用無參的構造方法）。如果我們重載了有參的構造方法，記得都要把無參的構造方法也寫出來（無論是否用到），因爲這可以幫助我們在創建對象的時候少踩坑。

構造方法有哪些特點？是否可被 override?

特點：

名字與類名相同。
沒有返回值，但不能用 void 聲明構造函數。
生成類的對象時自動執行，無需調用。

構造方法不能被 override（重寫）,但是可以 overload（重載）,所以你可以看到一個類中有多個構造函數的情況。

面向對象三大特徵

封裝

封裝是指把一個對象的狀態信息（也就是屬性）隱藏在對象內部，不允許外部對象直接訪問對象的內部信息。但是可以提供一些可以被外界訪問的方法來操作屬性。就好像我們看不到掛在牆上的空調的內部的零件信息（也就是屬性），但是可以通過遙控器（方法）來控制空調。如果屬性不想被外界訪問，我們大可不必提供方法給外界訪問。但是如果一個類沒有提供給外界訪問的方法，那麼這個類也沒有什麼意義了。就好像如果沒有空調遙控器，那麼我們就無法操控空凋製冷，空調本身就沒有意義了（當然現在還有很多其他方法，這裏只是爲了舉例子）。

public class Student {
    private int id;//id屬性私有化
    private String name;//name屬性私有化

    //獲取id的方法
    public int getId() {
        return id;
    }

    //設置id的方法
    public void setId(int id) {
        this.id = id;
    }

    //獲取name的方法
    public String getName() {
        return name;
    }

    //設置name的方法
    public void setName(String name) {
        this.name = name;
    }
}

繼承

不同類型的對象，相互之間經常有一定數量的共同點。例如，小明同學、小紅同學、小李同學，都共享學生的特性（班級、學號等）。同時，每一個對象還定義了額外的特性使得他們與衆不同。例如小明的數學比較好，小紅的性格惹人喜愛；小李的力氣比較大。繼承是使用已存在的類的定義作爲基礎建立新類的技術，新類的定義可以增加新的數據或新的功能，也可以用父類的功能，但不能選擇性地繼承父類。通過使用繼承，可以快速地創建新的類，可以提高代碼的重用，程序的可維護性，節省大量創建新類的時間，提高我們的開發效率。

關於繼承如下 3 點請記住：

子類擁有父類對象所有的屬性和方法（包括私有屬性和私有方法），但是父類中的私有屬性和方法子類是無法訪問，只是擁有。
子類可以擁有自己屬性和方法，即子類可以對父類進行擴展。
子類可以用自己的方式實現父類的方法。（以後介紹）。

多態

多態，顧名思義，表示一個對象具有多種的狀態。具體表現爲父類的引用指向子類的實例。

多態的特點:

對象類型和引用類型之間具有繼承（類）/實現（接口）的關係；
引用類型變量發出的方法調用的到底是哪個類中的方法，必須在程序運行期間才能確定；
多態不能調用“只在子類存在但在父類不存在”的方法；
如果子類重寫了父類的方法，真正執行的是子類覆蓋的方法，如果子類沒有覆蓋父類的方法，執行的是父類的方法。

String StringBuffer 和 StringBuilder 的區別是什麼? String 爲什麼是不可變的?

可變性

簡單的來說：String 類中使用 final 關鍵字修飾字符數組來保存字符串，private final char value[]，所以String 對象是不可變的。

補充（來自issue 675）：在 Java 9 之後，String 、StringBuilder 與 StringBuffer 的實現改用 byte 數組存儲字符串 private final byte[] value

而 StringBuilder 與 StringBuffer 都繼承自 AbstractStringBuilder 類，在 AbstractStringBuilder 中也是使用字符數組保存字符串char[]value 但是沒有用 final 關鍵字修飾，所以這兩種對象都是可變的。

StringBuilder 與 StringBuffer 的構造方法都是調用父類構造方法也就是AbstractStringBuilder 實現的，大家可以自行查閱源碼。

AbstractStringBuilder.java

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char[] value;

    /**
     * The count is the number of characters used.
     */
    int count;

    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }}

線程安全性

String 中的對象是不可變的，也就可以理解爲常量，線程安全。AbstractStringBuilder 是 StringBuilder 與 StringBuffer 的公共父類，定義了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 對方法加了同步鎖或者對調用的方法加了同步鎖，所以是線程安全的。StringBuilder 並沒有對方法進行加同步鎖，所以是非線程安全的。

性能

每次對 String 類型進行改變的時候，都會生成一個新的 String 對象，然後將指針指向新的 String 對象。StringBuffer 每次都會對 StringBuffer 對象本身進行操作，而不是生成新的對象並改變對象引用。相同情況下使用 StringBuilder 相比使用 StringBuffer 僅能獲得 10%~15% 左右的性能提升，但卻要冒多線程不安全的風險。

對於三者使用的總結：

操作少量的數據: 適用 String
單線程操作字符串緩衝區下操作大量數據: 適用 StringBuilder
多線程操作字符串緩衝區下操作大量數據: 適用 StringBuffer

Object 類的常見方法總結

Object 類是一個特殊的類，是所有類的父類。它主要提供了以下 11 個方法：


public final native Class<?> getClass()//native方法，用於返回當前運行時對象的Class對象，使用了final關鍵字修飾，故不允許子類重寫。

public native int hashCode() //native方法，用於返回對象的哈希碼，主要使用在哈希表中，比如JDK中的HashMap。
public boolean equals(Object obj)//用於比較2個對象的內存地址是否相等，String類對該方法進行了重寫用戶比較字符串的值是否相等。

protected native Object clone() throws CloneNotSupportedException//naitive方法，用於創建並返回當前對象的一份拷貝。一般情況下，對於任何對象 x，表達式 x.clone() != x 爲true，x.clone().getClass() == x.getClass() 爲true。Object本身沒有實現Cloneable接口，所以不重寫clone方法並且進行調用的話會發生CloneNotSupportedException異常。

public String toString()//返回類的名字@實例的哈希碼的16進制的字符串。建議Object所有的子類都重寫這個方法。

public final native void notify()//native方法，並且不能重寫。喚醒一個在此對象監視器上等待的線程(監視器相當於就是鎖的概念)。如果有多個線程在等待只會任意喚醒一個。

public final native void notifyAll()//native方法，並且不能重寫。跟notify一樣，唯一的區別就是會喚醒在此對象監視器上等待的所有線程，而不是一個線程。

public final native void wait(long timeout) throws InterruptedException//native方法，並且不能重寫。暫停線程的執行。注意：sleep方法沒有釋放鎖，而wait方法釋放了鎖 。timeout是等待時間。

public final void wait(long timeout, int nanos) throws InterruptedException//多了nanos參數，這個參數表示額外時間（以毫微秒爲單位，範圍是 0-999999）。 所以超時的時間還需要加上nanos毫秒。

public final void wait() throws InterruptedException//跟之前的2個wait方法一樣，只不過該方法一直等待，沒有超時時間這個概念

protected void finalize() throws Throwable { }//實例被垃圾回收器回收的時候觸發的操作

反射

何爲反射？

如果說大家研究過框架的底層原理或者咱們自己寫過框架的話，一定對反射這個概念不陌生。

反射之所以被稱爲框架的靈魂，主要是因爲它賦予了我們在運行時分析類以及執行類中方法的能力。

通過反射你可以獲取任意一個類的所有屬性和方法，你還可以調用這些方法和屬性。

反射機制優缺點

優點：可以讓咱們的代碼更加靈活、爲各種框架提供開箱即用的功能提供了便利
缺點：讓我們在運行時有了分析操作類的能力，這同樣也增加了安全問題。比如可以無視泛型參數的安全檢查（泛型參數的安全檢查發生在編譯時）。另外，反射的性能也要稍差點，不過，對於框架來說實際是影響不大的。Java Reflection: Why is it so slow?

反射的應用場景

像咱們平時大部分時候都是在寫業務代碼，很少會接觸到直接使用反射機制的場景。

但是，這並不代表反射沒有用。相反，正是因爲反射，你才能這麼輕鬆地使用各種框架。像 Spring/Spring Boot、MyBatis 等等框架中都大量使用了反射機制。

這些框架中也大量使用了動態代理，而動態代理的實現也依賴反射。

比如下面是通過 JDK 實現動態代理的示例代碼，其中就使用了反射類 Method 來調用指定的方法。

public class DebugInvocationHandler implements InvocationHandler {
    /**
     * 代理類中的真實對象
     */
    private final Object target;

    public DebugInvocationHandler(Object target) {
        this.target = target;
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        System.out.println("before method " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("after method " + method.getName());
        return result;
    }
}

另外，像 Java 中的一大利器註解的實現也用到了反射。

爲什麼你使用 Spring 的時候，一個@Component註解就聲明瞭一個類爲 Spring Bean 呢？爲什麼你通過一個 @Value註解就讀取到配置文件中的值呢？究竟是怎麼起作用的呢？

這些都是因爲你可以基於反射分析類，然後獲取到類/屬性/方法/方法的參數上的註解。你獲取到註解之後，就可以做進一步的處理。

異常

Java 異常類層次結構圖

圖片來自：https://simplesnippets.tech/exception-handling-in-java-part-1/

圖片來自：https://chercher.tech/java-programming/exceptions-java

在 Java 中，所有的異常都有一個共同的祖先 java.lang 包中的 Throwable 類。Throwable 類有兩個重要的子類 Exception（異常）和 Error（錯誤）。Exception 能被程序本身處理(try-catch)， Error 是無法處理的(只能儘量避免)。

Exception 和 Error 二者都是 Java 異常處理的重要子類，各自都包含大量子類。

Exception :程序本身可以處理的異常，可以通過 catch 來進行捕獲。Exception 又可以分爲受檢查異常(必須處理) 和不受檢查異常(可以不處理)。
Error ：Error 屬於程序無法處理的錯誤，我們沒辦法通過 catch 來進行捕獲。例如，Java 虛擬機運行錯誤（Virtual MachineError）、虛擬機內存不夠錯誤(OutOfMemoryError)、類定義錯誤（NoClassDefFoundError）等。這些異常發生時，Java 虛擬機（JVM）一般會選擇線程終止。

受檢查異常

Java 代碼在編譯過程中，如果受檢查異常沒有被 catch/throw 處理的話，就沒辦法通過編譯。比如下面這段 IO 操作的代碼。

除了RuntimeException及其子類以外，其他的Exception類及其子類都屬於受檢查異常。常見的受檢查異常有： IO 相關的異常、ClassNotFoundException 、SQLException...。

不受檢查異常

Java 代碼在編譯過程中，我們即使不處理不受檢查異常也可以正常通過編譯。

RuntimeException 及其子類都統稱爲非受檢查異常，例如：NullPointerException、NumberFormatException（字符串轉換爲數字）、ArrayIndexOutOfBoundsException（數組越界）、ClassCastException（類型轉換錯誤）、ArithmeticException（算術錯誤）等。

Throwable 類常用方法

public string getMessage():返回異常發生時的簡要描述
public string toString():返回異常發生時的詳細信息
public string getLocalizedMessage():返回異常對象的本地化信息。使用 Throwable 的子類覆蓋這個方法，可以生成本地化信息。如果子類沒有覆蓋該方法，則該方法返回的信息與 getMessage（）返回的結果相同
public void printStackTrace():在控制檯上打印 Throwable 對象封裝的異常信息

try-catch-finally

try塊： 用於捕獲異常。其後可接零個或多個 catch 塊，如果沒有 catch 塊，則必須跟一個 finally 塊。
catch塊： 用於處理 try 捕獲到的異常。
finally 塊： 無論是否捕獲或處理異常，finally 塊裏的語句都會被執行。當在 try 塊或 catch 塊中遇到 return 語句時，finally 語句塊將在方法返回之前被執行。

在以下 3 種特殊情況下，finally 塊不會被執行：

在 try 或 finally塊中用了 System.exit(int)退出程序。但是，如果 System.exit(int) 在異常語句之後，finally 還是會被執行
程序所在的線程死亡。
關閉 CPU。

下面這部分內容來自 issue:https://github.com/Snailclimb/JavaGuide/issues/190。

注意： 當 try 語句和 finally 語句中都有 return 語句時，在方法返回之前，finally 語句的內容將被執行，並且 finally 語句的返回值將會覆蓋原始的返回值。如下：

public class Test {
    public static int f(int value) {
        try {
            return value * value;
        } finally {
            if (value == 2) {
                return 0;
            }
        }
    }
}

如果調用 f(2)，返回值將是 0，因爲 finally 語句的返回值覆蓋了 try 語句塊的返回值。

使用 `try-with-resources` 來代替`try-catch-finally`

適用範圍（資源的定義）： 任何實現 java.lang.AutoCloseable或者 java.io.Closeable 的對象
關閉資源和 finally 塊的執行順序： 在 try-with-resources 語句中，任何 catch 或 finally 塊在聲明的資源關閉後運行

《Effecitve Java》中明確指出：

面對必須要關閉的資源，我們總是應該優先使用 try-with-resources 而不是try-finally。隨之產生的代碼更簡短，更清晰，產生的異常對我們也更有用。try-with-resources語句讓我們更容易編寫必須要關閉的資源的代碼，若採用try-finally則幾乎做不到這點。

Java 中類似於InputStream、OutputStream 、Scanner 、PrintWriter等的資源都需要我們調用close()方法來手動關閉，一般情況下我們都是通過try-catch-finally語句來實現這個需求，如下：

        //讀取文本文件的內容
        Scanner scanner = null;
        try {
            scanner = new Scanner(new File("D://read.txt"));
            while (scanner.hasNext()) {
                System.out.println(scanner.nextLine());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (scanner != null) {
                scanner.close();
            }
        }

使用 Java 7 之後的 try-with-resources 語句改造上面的代碼:

try (Scanner scanner = new Scanner(new File("test.txt"))) {
    while (scanner.hasNext()) {
        System.out.println(scanner.nextLine());
    }
} catch (FileNotFoundException fnfe) {
    fnfe.printStackTrace();
}

當然多個資源需要關閉的時候，使用 try-with-resources 實現起來也非常簡單，如果你還是用try-catch-finally可能會帶來很多問題。

通過使用分號分隔，可以在try-with-resources塊中聲明多個資源。

try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));
             BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")))) {
            int b;
            while ((b = bin.read()) != -1) {
                bout.write(b);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }

I\O 流

什麼是序列化?什麼是反序列化?

如果我們需要持久化 Java 對象比如將 Java 對象保存在文件中，或者在網絡傳輸 Java 對象，這些場景都需要用到序列化。

簡單來說：

序列化：將數據結構或對象轉換成二進制字節流的過程
反序列化：將在序列化過程中所生成的二進制字節流的過程轉換成數據結構或者對象的過程

對於 Java 這種面向對象編程語言來說，我們序列化的都是對象（Object）也就是實例化後的類(Class)，但是在 C++這種半面向對象的語言中，struct(結構體)定義的是數據結構類型，而 class 對應的是對象類型。

維基百科是如是介紹序列化的：

序列化（serialization）在計算機科學的數據處理中，是指將數據結構或對象狀態轉換成可取用格式（例如存成文件，存於緩衝，或經由網絡中發送），以留待後續在相同或另一臺計算機環境中，能恢復原先狀態的過程。依照序列化格式重新獲取字節的結果時，可以利用它來產生與原始對象相同語義的副本。對於許多對象，像是使用大量引用的複雜對象，這種序列化重建的過程並不容易。面向對象中的對象序列化，並不概括之前原始對象所關係的函數。這種過程也稱爲對象編組（marshalling）。從一系列字節提取數據結構的反向操作，是反序列化（也稱爲解編組、deserialization、unmarshalling）。

綜上：序列化的主要目的是通過網絡傳輸對象或者說是將對象存儲到文件系統、數據庫、內存中。

https://www.corejavaguru.com/java/serialization/interview-questions-1

Java 序列化中如果有些字段不想進行序列化，怎麼辦？

對於不想進行序列化的變量，使用transient關鍵字修飾。

transient 關鍵字的作用是：阻止實例中那些用此關鍵字修飾的的變量序列化；當對象被反序列化時，被 transient 修飾的變量值不會被持久化和恢復。transient 只能修飾變量，不能修飾類和方法。

獲取用鍵盤輸入常用的兩種方法

方法 1：通過 Scanner

Scanner input = new Scanner(System.in);
String s  = input.nextLine();
input.close();

方法 2：通過 BufferedReader

BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
String s = input.readLine();

Java 中 IO 流分爲幾種?

按照流的流向分，可以分爲輸入流和輸出流；
按照操作單元劃分，可以劃分爲字節流和字符流；
按照流的角色劃分爲節點流和處理流。

Java Io 流共涉及 40 多個類，這些類看上去很雜亂，但實際上很有規則，而且彼此之間存在非常緊密的聯繫， Java I0 流的 40 多個類都是從如下 4 個抽象類基類中派生出來的。

InputStream/Reader: 所有的輸入流的基類，前者是字節輸入流，後者是字符輸入流。
OutputStream/Writer: 所有輸出流的基類，前者是字節輸出流，後者是字符輸出流。

按操作方式分類結構圖：

按操作對象分類結構圖：

既然有了字節流,爲什麼還要有字符流?

問題本質想問：不管是文件讀寫還是網絡發送接收，信息的最小存儲單元都是字節，那爲什麼 I/O 流操作要分爲字節流操作和字符流操作呢？

回答：字符流是由 Java 虛擬機將字節轉換得到的，問題就出在這個過程還算是非常耗時，並且，如果我們不知道編碼類型就很容易出現亂碼問題。所以， I/O 流就乾脆提供了一個直接操作字符的接口，方便我們平時對字符進行流操作。如果音頻文件、圖片等媒體文件用字節流比較好，如果涉及到字符的話使用字符流比較好。

2.7w字！Java基礎面試題/知識點總結！（2021 最新版）

基礎概念與常識

Java 語言有哪些特點?

JVM vs JDK vs JRE

JVM

JDK 和 JRE

爲什麼說 Java 語言“編譯與解釋並存”？

Oracle JDK 和 OpenJDK 的對比

Java 和 C++的區別?

import java 和 javax 有什麼區別？

基本語法

字符型常量和字符串常量的區別?

註釋

標識符和關鍵字的區別是什麼？

Java 中有哪些常見的關鍵字？

自增自減運算符

continue、break、和 return 的區別是什麼？

Java 泛型瞭解麼？什麼是類型擦除？介紹一下常用的通配符？

==和 equals 的區別

hashCode()與 equals()

基本數據類型

Java 中的幾種基本數據類型是什麼？對應的包裝類型是什麼？各自佔用多少字節呢？

自動裝箱與拆箱

8 種基本類型的包裝類和常量池

方法（函數）

什麼是方法的返回值?

方法有哪幾種類型？

在一個靜態方法內調用一個非靜態成員爲什麼是非法的?

靜態方法和實例方法有何不同？

爲什麼 Java 中只有值傳遞？

重載和重寫的區別

重載

重寫

深拷貝 vs 淺拷貝

Java 面向對象

面向對象和麪向過程的區別

成員變量與局部變量的區別有哪些？

創建一個對象用什麼運算符?對象實體與對象引用有何不同?

對象的相等與指向他們的引用相等,兩者有什麼不同?

一個類的構造方法的作用是什麼? 若一個類沒有聲明構造方法，該程序能正確執行嗎? 爲什麼?

構造方法有哪些特點？是否可被 override?

面向對象三大特徵

封裝

繼承

多態

String StringBuffer 和 StringBuilder 的區別是什麼? String 爲什麼是不可變的?

Object 類的常見方法總結

反射

何爲反射？

反射機制優缺點

反射的應用場景

異常

Java 異常類層次結構圖

Throwable 類常用方法

try-catch-finally

使用 try-with-resources 來代替try-catch-finally

I\O 流

什麼是序列化?什麼是反序列化?

Java 序列化中如果有些字段不想進行序列化，怎麼辦？

獲取用鍵盤輸入常用的兩種方法

Java 中 IO 流分爲幾種?

既然有了字節流,爲什麼還要有字符流?

4. 參考

使用 `try-with-resources` 來代替`try-catch-finally`