1. 異常是什么

?? 異常：程序在運行過程中產生的不正常情況

• 程序在運行的時候，發(fā)生了一些不被預期的事件，從而沒有按照我們編寫的代碼執(zhí)行，這就是異常。

舉一些例子：

（1）算術異常

System.out.println(5/0)

// 執(zhí)行結果
Exception in thread "main" java.lang.ArithmeticException: / by zero

• 這個時候你的程序是可以正常編譯的，但是在運行的時候，因為你用0做了除數(shù)，會拋出 java.lang.ArithmeticException  的異常。

（2）數(shù)組越界異常

int[] arr = {1, 2, 3};
System.out.println(arr[100])

// 執(zhí)行結果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100

（3）空指針

int[] arr = null;
System.out.println(arr.length);

// 執(zhí)行結果
Exception in thread "main" java.lang.NullPointerException

（4）其他：

• 輸入了錯誤的數(shù)據(jù)，比如：程序需要的是int類型數(shù)據(jù)，而用戶輸入了一串字符串；
• 對象沒有初始化就調用：下面這段代碼就會提示空指針異常；

  String str = null;
  int length = str.length(); 

• 要打開的文件不存在;

• 網(wǎng)絡通信時連接中斷，或者JVM內存溢出。

2. 異常體系結構

異常種類繁多，為了對不同異?；蛘咤e誤進行很好的分類管理，Java內部維護了一個異常的體系結構：

從上圖中可以看到： 

• Throwable：是異常體系的頂層類，其派生出兩個重要的子類，Error 和  Exception
•  Error：指的是Java虛擬機無法解決的嚴重問題，比如：JVM的內部錯誤、資源耗盡等。典型代表：StackOverflowError和OutOfMemoryError，一旦發(fā)生回力乏術。
•  Exception：異常產生后程序員可以通過代碼進行處理，使程序繼續(xù)執(zhí)行。比如：感冒、發(fā)燒。我們平時所說的異常就是 Exception
•  Exception的直接子類：編譯時異常，要求程序員在編寫程序階段必須預先對這些異常進行處理，如果不處理編譯器報錯，因此得名編譯時異常
• RuntimeException：運行時異常。在編寫程序階段程序員可以預先處理，也可以不管，都行

3. 異常的分類

編譯時異常和運行時異常，都發(fā)生在運行階段。編譯階段異常是不會發(fā)生的。

異?？赡茉诰幾g時發(fā)生，也可能在程序運行時發(fā)生，根據(jù)發(fā)生的時機不同，可以將異常分為：

3.1 編譯時異常

在程序編譯期間發(fā)生的異常，稱為編譯時異常，也稱為 受檢查異常 (Checked Exception)

編譯時異常因為什么而得名？

因為編譯時異常必須在編譯（編寫）階段預先處理，如果不處理編譯器報錯，因此得名

所有異常都是運行階段發(fā)生的。因為只有程序運行階段才可以new對象

因為異常的發(fā)生都是new異常對象

class Person {
    private String name;
    private String gender;
    int age;
    // 想要讓該類支持深拷貝，覆寫Object類的clone方法即可
    @Override
    public Person clone() {
        return (Person)super.clone();
    }
}
編譯時報錯：
Error:(17, 35) java: 未報告的異常錯誤java.lang.CloneNotSupportedException; 必須對其進行捕獲或聲明以便拋出

3.2 運行時異常

在程序執(zhí)行期間發(fā)生的異常，稱為運行時異常，也稱為非受檢查異常(Unchecked Exception)RunTimeException以及其子類對應的異常，都稱為運行時異常。

比如：NullPointerException、ArrayIndexOutOfBoundsException、ArithmeticException。

ClassCastException(類轉換異常)
IndexOutOfBoundsException(數(shù)組越界)
NullPointerException(空指針)
ArrayStoreException(數(shù)據(jù)存儲異常，操作數(shù)組時類型不一致)

• 運行時指的是程序已經(jīng)編譯通過得到 class 文件了，再由 JVM 執(zhí)行過程中出現(xiàn)的錯誤

??注意：異常是Java中的錯誤，但是并不是所有的錯誤都是異常。比如：編譯時出現(xiàn)的語法性錯誤，不能稱之為異常。你在定義變量名的時候沒有依照Java的規(guī)則，在語句的結尾少了一個分號，那么運行出來結果是提示是錯誤 java.lang.Error；這是 "編譯期" 出錯。

3.3 區(qū)別

編譯時異常和運行時異常的區(qū)別是什么？

• 編譯時異常一般發(fā)生的概率比較高。對于一些發(fā)生概率高的異常，需要在編譯時預先對其處理
• 運行時異常一般發(fā)生的概率很低。你可以預先處理，也可以不處理

假設java中沒有對異常進行劃分，沒有分編譯時異常和運行時異常，所有的異常都需要在編寫階段對其預處理，將是怎樣的效果？

• 首先，如果這樣做的話，程序肯定是絕對的安全。
• 但是程序員就太累，到處都是處理異常的代碼，顯得很亂。

4. 異常的處理

4.1 防御式編程

錯誤在代碼中是客觀存在的. 因此我們要讓程序出現(xiàn)問題的時候及時通知程序猿. 主要的方式：

（1） LBYL: Look Before You Leap. 在操作之前就做充分的檢查. 即：事前防御型

• 缺陷：正常流程和錯誤處理流程代碼混在一起, 代碼整體顯的比較混亂。

（2） EAFP: It's Easier to Ask Forgiveness than Permission. "事后獲取原諒比事前獲取許可更容易". 也就是先操作, 遇到問題再處理. 即：事后認錯型

• 優(yōu)勢：正常流程和錯誤流程是分離開的, 程序員更關注正常流程，代碼更清晰，容易理解代碼

異常處理的核心思想就是 EAFP。
在Java中，異常處理主要的5個關鍵字：throw、try、catch、final、throws。

4.2 異常的拋出

在編寫程序時，如果程序中出現(xiàn)錯誤，此時就需要將錯誤的信息告知給調用者，比如：參數(shù)檢測。
在Java中，可以借助 throw關鍵字

• 主動拋出一個指定的異常對象，將錯誤信息告知給調用者。
• 具體語法如下：

  throw new XXXException("異常產生的原因");

首先我們來看系統(tǒng)自動拋出異常：

public static void main(String[] args) {
    int a = 10;
    int b = 0;
    System.out.println(a/b);
}

運行這段代碼系統(tǒng)會自動拋出 java.lang.ArithmeticException 異常。

這段程序使用 throw關鍵字也可以實現(xiàn)：

public static void main(String[] args) {
    int a = 10;
    int b = 0;
    if(b == 0){
        throw new ArithmeticException("/ by zero");
    }
    System.out.println(a/b);
}

throw是語句拋出一個異常，一般是在代碼塊的內部，當程序出現(xiàn)某種邏輯錯誤時由程序員主動拋出某種特定類型的異常。

【注意事項】

•  throw必須寫在方法體內部
•  拋出的對象必須是 Exception 或者 Exception 的子類對象
•  如果拋出的是 RuntimeException 或者 RuntimeException 的子類，則可以不用處理，直接交給JVM來處理
•  如果拋出的是編譯時異常，用戶必須處理，否則無法通過編譯
•  異常一旦拋出，其后的代碼就不會執(zhí)行
•  使用 throw關鍵字主動拋出檢測性異常的時候，在方法名上必須使用 throws表明調用這個方法可能存在要拋出的異常（異常聲明）

4.3 異常的捕獲

?? 異常的捕獲，也就是異常的具體處理方式，主要有兩種：異常聲明throws 以及 try-catch捕獲處理。

4.3.1 異常聲明 throws

?? 處在方法聲明時參數(shù)列表之后，當方法中拋出編譯時異常，用戶不想處理該異常，此時就可以借助throws將異常拋給方法的調用者來處理。即當前方法不處理異常，提醒方法的調用者處理異常.

語法格式：
修飾符  返回值類型  方法名(參數(shù)列表) throws 異常類型1，異常類型2...{
}

?? 還記得我們異常拋出那里說的：使用throw關鍵字主動拋出檢測性異常的時候，在方法名上必須使用throws表明調用這個方法可能存在要拋出的異常（異常聲明）

舉個例子：

public static void test1(int a,int b){
    if(b == 0)
        throw new ArithmeticException("/by zero");
    System.out.println(a/b);
}

public static void test2(int a,int b) throws FileNotFoundException{
    throw new FileNotFoundException();
}

• ArithmeticException屬于運行時異常，是在運行時檢測的，所以上述代碼編譯是能通過的
• FileNotFoundException是屬于檢測型異常，是在編譯之前就需要處理的，所以第二段程序要加上throws才能通過編譯。

【注意事項】

•  throws必須跟在方法的參數(shù)列表之后
•  聲明的異常必須是 Exception 或者 Exception 的子類對象
•  方法內部如果拋出了多個異常，throws之后必須跟多個異常類型，之間用逗號隔開，如果拋出多個異常類型具有父子關系，直接聲明父類即可。
•  調用聲明拋出異常的方法時，調用者必須對該異常進行處理，或者繼續(xù)使用throws拋出

說到這個檢測型異常，我們需要了解一下常見的檢測型異常和非檢測型異常

4.3.2 常用的異常類

非檢測型異常：

檢測型異常：

4.3.3 try-catch捕獲并處理

?? throws 對異常并沒有真正處理，而是將異常報告給拋出異常方法的調用者，由調用者處理。如果真正要對異常進行處理，就需要 try-catch

語法格式：
try{
 // 將可能出現(xiàn)異常的代碼放在這里
}catch(要捕獲的異常類型  e){
   // 如果try中的代碼拋出異常了，此處catch捕獲時異常類型與try中拋出的異常類型一致時，或者是try中拋出異常的基類
時，就會被捕獲到
   // 對異常就可以正常處理，處理完成后，跳出try-catch結構，繼續(xù)執(zhí)行后序代碼
}[catch(異常類型 e){
  // 對異常進行處理
}finally{
   // 此處代碼一定會被執(zhí)行到
}]
// 后序代碼
// 當異常被捕獲到時，異常就被處理了，這里的后序代碼一定會執(zhí)行
// 如果捕獲了，由于捕獲時類型不對，那就沒有捕獲到，這里的代碼就不會被執(zhí)行
 

注意：

 []中表示可選項，可以添加，也可以不用添加

 try中的代碼可能會拋出異常，也可能不會

舉個例子：

private static void m1() throws FileNotFoundException {
    System.out.println("m1 begin");
    m2();
    // 以上代碼出異常，這里是無法執(zhí)行的。
    System.out.println("m1 over");
}

try {
    m1();
    // m1方法出異常，下面代碼不執(zhí)行。
    System.out.println("hello world!");//不執(zhí)行
} catch (FileNotFoundException e){ 
	//異常處理
    System.out.println("出異常了！！");
    System.out.println(e); 
}
System.out.println("hello world"); //會執(zhí)行

【注意事項】

（1）try塊內拋出異常位置之后的代碼將不會被執(zhí)行

（2）如果拋出異常類型與catch時異常類型不匹配，即異常不會被成功捕獲，也就不會被處理，繼續(xù)往外拋，直到JVM收到后中斷程序----異常是按照類型來捕獲的

public static void main(String[] args) {
  try {
    int[] array = {1,2,3};
    System.out.println(array[3]);  // 此處會拋出數(shù)組越界異常
 }catch (NullPointerException e){  // 捕獲時候捕獲的是空指針異常--真正的異常無法被捕獲到
    e.printStackTrace();
 }
  System.out.println("后序代碼");
}
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
at day20210917.ArrayOperator.main(ArrayOperator.java:24)

（3）try中可能會拋出多個不同的異常對象，則必須用多個catch來捕獲----即多種異常，多次捕獲

public static void main(String[] args) {
	int[] arr = { 1, 2, 3 };
	try {
		System.out.println("before");
		//arr = null;
		System.out.println(arr[100]);
		System.out.println("after");
	}
	catch (ArrayIndexOutOfBoundsException e) {
		System.out.println("這是個數(shù)組下標越界異常");
		e.printStackTrace();
	}
	catch (NullPointerException e) {
		System.out.println("這是個空指針異常");
		e.printStackTrace();
	}
	System.out.println("after try catch");
}

如果多個異常的處理方式是完全相同, 也可以寫成這樣：
catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
...
}

• 如果異常之間具有父子關系，一定是子類異常在前catch，父類異常在后catch，否則語法錯誤

public static void main(String[] args) {
	int[] arr = { 1, 2, 3 };
	try {
		System.out.println("before");
		arr = null;
		System.out.println(arr[100]);
		System.out.println("after");
	}
	catch (Exception e) {  // Exception可以捕獲到所有異常
		e.printStackTrace();
	}
	catch (NullPointerException e) {  // 永遠都捕獲執(zhí)行到
		e.printStackTrace();
	}

	System.out.println("after try catch");
}

（4） 可以通過一個catch捕獲所有的異常，即多個異常，一次捕獲(不推薦)

public static void main(String[] args) {
	int[] arr = { 1, 2, 3 };
	try {
		System.out.println("before");
		arr = null;
		System.out.println(arr[100]);
		System.out.println("after");
	}
	catch (Exception e) {
		e.printStackTrace();
	}
	System.out.println("after try catch");
}

• 由于 Exception 類是所有異常類的父類。 因此可以用這個類型表示捕捉所有異常.
• 補充：catch 進行類型匹配的時候，不光會匹配相同類型的異常對象，也會捕捉目標異常類型的子類對象.
• 如剛才的代碼，NullPointerException 和 ArrayIndexOutOfBoundsException 都是 Exception 的子類,因此都能被捕獲到.

4.3.4 finally

?? 在寫程序時，有些特定的代碼，不論程序是否發(fā)生異常，都需要執(zhí)行，比如程序中打開的資源：網(wǎng)絡連接、數(shù)據(jù)庫連接、IO流等，在程序正?；蛘弋惓Ｍ顺鰰r，必須要對資源進進行回收。另外，因為異常會引發(fā)程序的跳轉，可能導致有些語句執(zhí)行不到，finally就是用來解決這個問題的。

在finally子句中的代碼是最后執(zhí)行的，并且是 一定會執(zhí)行 的，即使try語句塊中的代碼出現(xiàn)了異常。

finally子句必須和try一起出現(xiàn)，不能單獨編寫。

語法格式：
try{
 // 可能會發(fā)生異常的代碼
}catch(異常類型  e){
 // 對捕獲到的異常進行處理
}finally{
 // 此處的語句無論是否發(fā)生異常，都會被執(zhí)行到
}
// 如果沒有拋出異常，或者異常被捕獲處理了，這里的代碼也會執(zhí)行

案例1：finally語句通常使用在finally語句塊中完成 資源的釋放/關閉。

public static void main(String[] args) {
	try {
		int[] arr = { 1,2,3 };
		arr[100] = 10;
		arr[0] = 10;
	} catch (ArrayIndexOutOfBoundsException e) {
		System.out.println(e);
	} finally {
		System.out.println("finally中的代碼一定會執(zhí)行");
	}

	System.out.println("如果沒有拋出異常，或者異常被處理了，try-catch后的代碼也會執(zhí)行");
}

案例2：try和finally聯(lián)用，沒有catch

public static void main(String[] args) {
	try {
		System.out.println("try...");
		return;
	}
	finally {
		System.out.println("finally...");
	}

	// 這里不能寫語句，因為這個代碼是無法執(zhí)行到的。
	//System.out.println("Hello World!");
}

注意：

• try不能單獨使用。
• try finally可以聯(lián)合使用。
• 放在finally語句塊中的代碼是一定會執(zhí)行的，一般在finally中進行一些資源清理的掃尾工作。

•  finally子句失效：System.exit(0) ; 只有這個可以治 finally 

  public static void main(String[] args) {
  	try {
  		System.out.println("try...");
  		// 退出JVM
  		System.exit(0); // 退出JVM之后，finally語句中的代碼就不執(zhí)行了！
  	}
  	finally {
  		System.out.println("finally...");
  	}
  }

給大家看一個題：

// 下面程序輸出什么？
public static void main(String[] args) {
  System.out.println(func());
}
public static int func() {
  try {
    return 10;
 } finally {
    return 20;
 }
}


A: 10  B: 20  C: 30  D: 編譯失敗

finally 執(zhí)行的時機是在方法返回之前(try 或者 catch 中如果有 return 會在這個 return 之前執(zhí)行 finally). 但是如果 finally 中也存在 return 語句, 那么就會執(zhí)行 finally 中的 return, 從而不會執(zhí)行到 try 中原有的 return

• 一般我們不建議在 finally 中寫 return (被編譯器當做一個警告).

4.4 異常處理流程

首先在學習這個之前，我們先來了解什么是 "調用棧" ？

• 方法之間是存在相互調用關系的, 這種調用關系我們可以用 "調用棧" 來描述. 在 JVM 中有一塊內存空間稱為"虛擬機棧" 專門存儲方法之間的調用關系. 當代碼中出現(xiàn)異常的時候, 我們就可以使用 e.printStackTrace();  的方式查看出現(xiàn)異常代碼的調用棧.

案例：

public static void main(String[] args) {
	try {
		func();
	}
	catch (ArrayIndexOutOfBoundsException e) {
		e.printStackTrace();
	}
	System.out.println("在 try catch 之后");
}
public static void func() {
	int[] arr = { 1, 2, 3 };
	System.out.println(arr[100]); // 指針越界
}

如果向上一直傳遞都沒有合適的方法處理異常, 最終就會交給 JVM 處理, 程序就會異常終止

• (和我們最開始未使用 try catch 時是一樣的).

public static void main(String[] args) {
    func();
    System.out.println("在 try catch 之后");
}
public static void func() {
    int[] arr = { 1, 2, 3 };
    System.out.println(arr[100]); // 指針越界
}

可以看到, 程序已經(jīng)異常終止了, 沒有執(zhí)行到 System.out.println("在 try catch 之后"); 這一行

【異常處理流程總結】

程序先執(zhí)行 try 中的代碼

如果 try 中的代碼出現(xiàn)異常, 就會結束 try 中的代碼, 看和 catch 中的異常類型是否匹配.

如果找到匹配的異常類型, 就會執(zhí)行 catch 中的代碼

如果沒有找到匹配的異常類型, 就會將異常向上傳遞到上層調用者.

無論是否找到匹配的異常類型, finally 中的代碼都會被執(zhí)行到(在該方法結束之前執(zhí)行).

如果上層調用者也沒有處理的了異常, 就繼續(xù)向上傳遞.

一直到 main 方法也沒有合適的代碼處理異常, 就會交給 JVM 來進行處理, 此時程序就會異常終止.

5. 自定義異常

?? 前面談到的都是系統(tǒng)自帶的異常，但是如果我們是在開發(fā)一個復雜項目，就經(jīng)常會遇到系統(tǒng)自帶的異常不能滿足我們的需求的情況，所以這個時候就需要我們自己來定義異常了。

使用自定義異常
?? 我們一般使用繼承Exception類的方式來自定義異常，那具體怎么進行呢？

很簡單，我們只需要繼承Exception，再將信息傳遞給父類就可以了：

class 自定義異常名 extends Exception{
    //因為Exception已經(jīng)實現(xiàn)了很多異常處理的方法了屬性了，
    //所以自定義異常只需要將信息傳遞給父類（使用super關鍵字）即可
}

舉個例子：

• 定義一個自定義異常，判斷用戶名是否小于三位，如果用戶名小于三位，就拋出一個自定義異常。

public class Task {
    /********* Begin *********/
    public static void main(String[] args) throws Exception{
        Scanner sc = new Scanner(System.in);
        String username = sc.next();

        //判斷用戶名
        if(username.length() < 3){
            throw new MyException("用戶名小于三位Exception");
        }
        else System.out.println("用戶名格式正確");
    }
}

class MyException extends Exception{
    MyException(String s){
        super(s);
    }
}

注意事項

• 自定義異常通常會繼承自 Exception 或者 RuntimeException
• 繼承自 Exception 的異常默認是受查異常
• 繼承自 RuntimeException 的異常默認是非受查異常

6. 小結

?? 關于異常的處理方式
異常的種類有很多, 我們要根據(jù)不同的業(yè)務場景來決定.

• 對于比較嚴重的問題(例如和算錢相關的場景), 應該讓程序直接崩潰, 防止造成更嚴重的后果
• 對于不太嚴重的問題(大多數(shù)場景), 可以記錄錯誤日志, 并通過監(jiān)控報警程序及時通知程序員
• 對于可能會恢復的問題(和網(wǎng)絡相關的場景), 可以嘗試進行重試.

一般來說都會采取的是經(jīng)過簡化的第二種方式. 我們記錄的錯誤日志是出現(xiàn)異常的方法調用信息, 能很快速的讓我們找到出現(xiàn)異常的位置. 以后在實際工作中我們會采取更完備的方式來記錄異常信息.

到此這篇關于Java異常處理及自定義異常的文章就介紹到這了,更多相關Java異常處理內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！