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

這篇《Java 基礎知識總結》是 JavaGuide 上閱讀量最高的一篇文章，因爲我對其進行了重構完善而且修復了不少小問題，因此，在segmentfault同步一下！

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

基礎概念與常識

Java 語言有哪些特色?

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

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

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 的全部部分，除了咱們考慮商業功能的部分。

總結：

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

🌈 拓展一下：

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

相關閱讀👍：《Differences Between Oracle JDK and OpenJDK》

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 沒有區別。這都是一個名字。

基本語法

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

1. 形式 : 字符常量是單引號引發的一個字符，字符串常量是雙引號引發的 0 個或若干個字符
2. 含義 : 字符常量至關於一個整型值( ASCII 值),能夠參加表達式運算; 字符串常量表明一個地址值(該字符串在內存中存放位置)

3. 佔內存大小 ： 字符常量只佔 2 個字節; 字符串常量佔若干個字節 (注意： char 在 Java 中佔兩個字節),

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

java 編程思想第四版：2.2.2 節

註釋

Java 中的註釋有三種：

1. 單行註釋
2. 多行註釋
3. 文檔註釋。

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

《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 的區別是什麼？

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

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

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

1. return; ：直接使用 return 結束方法執行，用於沒有返回值函數的方法
2. 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 種基本數據類型，分別爲：

1. 6 種數字類型 ：byte、short、int、long、float、double
2. 1 種字符類型：char
3. 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 位，可是實際中會考慮計算機高效存儲因素。

注意：

1. Java 裏使用 long 類型的數據必定要在數值後面加上 L，不然將做爲整型解析。
2. 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 的相關知識，靜態方法是屬於類的，在類加載的時候就會分配內存，能夠經過類名直接訪問。而非靜態成員屬於實例對象，只有在對象實例化以後才存在，而後經過類的實例對象去訪問。在類的非靜態成員不存在的時候靜態成員就已經存在了，此時調用在內存中還不存在的非靜態成員，屬於非法操做。

靜態方法和實例方法有何不一樣？

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

爲何 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 的值進行交換，並不會影響到 num一、num2。由於，a、b 中的值，只是從 num一、num2 的複製過來的。也就是說，a、b 至關於 num一、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 核心技術》對重載這個概念的介紹：

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

重寫

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

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

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

暖心的 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 淺拷貝

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

Java 面向對象

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

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

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

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

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

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

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

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

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

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

對象的相等與指向他們的引用相等,二者有什麼不一樣?

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

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

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

若是一個類沒有聲明構造方法，也能夠執行！由於一個類即便沒有聲明構造方法也會有默認的不帶參數的構造方法。若是咱們本身添加了類的構造方法（不管是否有參），Java 就不會再添加默認的無參數的構造方法了，這時候，就不能直接 new 一個對象而不傳遞參數了，因此咱們一直在不知不覺地使用構造方法，這也是爲何咱們在建立對象的時候後面要加一個括號（由於要調用無參的構造方法）。若是咱們重載了有參的構造方法，記得都要把無參的構造方法也寫出來（不管是否用到），由於這能夠幫助咱們在建立對象的時候少踩坑。

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

特色：

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

構造方法不能被 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 點請記住：

1. 子類擁有父類對象全部的屬性和方法（包括私有屬性和私有方法），可是父類中的私有屬性和方法子類是沒法訪問，只是擁有。
2. 子類能夠擁有本身屬性和方法，即子類能夠對父類進行擴展。
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% 左右的性能提高，但卻要冒多線程不安全的風險。

對於三者使用的總結：

1. 操做少許的數據: 適用 String
2. 單線程操做字符串緩衝區下操做大量數據: 適用 StringBuilder
3. 多線程操做字符串緩衝區下操做大量數據: 適用 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 異常類層次結構圖

<p style="font-size:13px;text-align:right">圖片來自：https://simplesnippets.tech/e...</p>

<p style="font-size:13px;text-align:right">圖片來自：https://chercher.tech/java-pr...</p>

在 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 塊不會被執行：

1. 在 try 或 finally塊中用了 System.exit(int)退出程序。可是，若是 System.exit(int) 在異常語句以後，finally 仍是會被執行
2. 程序所在的線程死亡。
3. 關閉 CPU。

下面這部份內容來自 issue:https://github.com/Snailclimb...。

注意： 當 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

1. 適用範圍（資源的定義）： 任何實現 java.lang.AutoCloseable或者 java.io.Closeable 的對象
2. 關閉資源和 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）。

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

<p style="text-align:right;font-size:13px;color:gray">https://www.corejavaguru.com/...</p>

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 流就乾脆提供了一個直接操做字符的接口，方便咱們平時對字符進行流操做。若是音頻文件、圖片等媒體文件用字節流比較好，若是涉及到字符的話使用字符流比較好。

4. 參考

• https://stackoverflow.com/que...
• https://www.educba.com/oracle...
• https://stackoverflow.com/que... 基礎概念與常識