1. 異常是什么

?? 異常：程序在運(yùn)行過(guò)程中產(chǎn)生的不正常情況

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

舉一些例子：

（1）算術(shù)異常

System.out.println(5/0)

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

• 這個(gè)時(shí)候你的程序是可以正常編譯的，但是在運(yùn)行的時(shí)候，因?yàn)槟阌?做了除數(shù)，會(huì)拋出 java.lang.ArithmeticException  的異常。

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

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

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

（3）空指針

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

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

（4）其他：

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

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

• 要打開(kāi)的文件不存在;

• 網(wǎng)絡(luò)通信時(shí)連接中斷，或者JVM內(nèi)存溢出。

2. 異常體系結(jié)構(gòu)

異常種類(lèi)繁多，為了對(duì)不同異?；蛘咤e(cuò)誤進(jìn)行很好的分類(lèi)管理，Java內(nèi)部維護(hù)了一個(gè)異常的體系結(jié)構(gòu)：

從上圖中可以看到： 

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

3. 異常的分類(lèi)

編譯時(shí)異常和運(yùn)行時(shí)異常，都發(fā)生在運(yùn)行階段。編譯階段異常是不會(huì)發(fā)生的。

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

3.1 編譯時(shí)異常

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

編譯時(shí)異常因?yàn)槭裁炊妹?/strong>

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

ClassCastException(類(lèi)轉(zhuǎn)換異常)
IndexOutOfBoundsException(數(shù)組越界)
NullPointerException(空指針)
ArrayStoreException(數(shù)據(jù)存儲(chǔ)異常，操作數(shù)組時(shí)類(lèi)型不一致)

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

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);
}

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

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();
}

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

private static void m1() throws FileNotFoundException {
    System.out.println("m1 begin");
    m2();
    // 以上代碼出異常，這里是無(wú)法執(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"); //會(huì)執(zhí)行

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

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("這是個(gè)數(shù)組下標(biāo)越界異常");
		e.printStackTrace();
	}
	catch (NullPointerException e) {
		System.out.println("這是個(gè)空指針異常");
		e.printStackTrace();
	}
	System.out.println("after try catch");
}

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

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) {  // 永遠(yuǎn)都捕獲執(zhí)行到
		e.printStackTrace();
	}

	System.out.println("after 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 (Exception e) {
		e.printStackTrace();
	}
	System.out.println("after try catch");
}

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

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

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

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

案例1：finally語(yǔ)句通常使用在finally語(yǔ)句塊中完成 資源的釋放/關(guān)閉。

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中的代碼一定會(huì)執(zhí)行");
	}

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

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

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

	// 這里不能寫(xiě)語(yǔ)句，因?yàn)檫@個(gè)代碼是無(wú)法執(zhí)行到的。
	//System.out.println("Hello World!");
}

注意：

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

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

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

給大家看一個(gè)題：

// 下面程序輸出什么？
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í)行的時(shí)機(jī)是在方法返回之前(try 或者 catch 中如果有 return 會(huì)在這個(gè) return 之前執(zhí)行 finally). 但是如果 finally 中也存在 return 語(yǔ)句, 那么就會(huì)執(zhí)行 finally 中的 return, 從而不會(huì)執(zhí)行到 try 中原有的 return

• 一般我們不建議在 finally 中寫(xiě) return (被編譯器當(dāng)做一個(gè)警告).

4.4 異常處理流程

首先在學(xué)習(xí)這個(gè)之前，我們先來(lái)了解什么是 "調(diào)用棧" ？

• 方法之間是存在相互調(diào)用關(guān)系的, 這種調(diào)用關(guān)系我們可以用 "調(diào)用棧" 來(lái)描述. 在 JVM 中有一塊內(nèi)存空間稱(chēng)為"虛擬機(jī)棧" 專(zhuān)門(mén)存儲(chǔ)方法之間的調(diào)用關(guān)系. 當(dāng)代碼中出現(xiàn)異常的時(shí)候, 我們就可以使用 e.printStackTrace();  的方式查看出現(xiàn)異常代碼的調(diào)用棧.

案例：

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]); // 指針越界
}

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

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

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)異常終止了, 沒(méi)有執(zhí)行到 System.out.println("在 try catch 之后"); 這一行

【異常處理流程總結(jié)】

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

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

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

如果沒(méi)有找到匹配的異常類(lèi)型, 就會(huì)將異常向上傳遞到上層調(diào)用者.

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

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

一直到 main 方法也沒(méi)有合適的代碼處理異常, 就會(huì)交給 JVM 來(lái)進(jìn)行處理, 此時(shí)程序就會(huì)異常終止.

5. 自定義異常

?? 前面談到的都是系統(tǒng)自帶的異常，但是如果我們是在開(kāi)發(fā)一個(gè)復(fù)雜項(xiàng)目，就經(jīng)常會(huì)遇到系統(tǒng)自帶的異常不能滿(mǎn)足我們的需求的情況，所以這個(gè)時(shí)候就需要我們自己來(lái)定義異常了。

使用自定義異常
?? 我們一般使用繼承Exception類(lèi)的方式來(lái)自定義異常，那具體怎么進(jìn)行呢？

很簡(jiǎn)單，我們只需要繼承Exception，再將信息傳遞給父類(lèi)就可以了：

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

舉個(gè)例子：

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

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

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

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

注意事項(xiàng)

• 自定義異常通常會(huì)繼承自 Exception 或者 RuntimeException
• 繼承自 Exception 的異常默認(rèn)是受查異常
• 繼承自 RuntimeException 的異常默認(rèn)是非受查異常

6. 小結(jié)

?? 關(guān)于異常的處理方式
異常的種類(lèi)有很多, 我們要根據(jù)不同的業(yè)務(wù)場(chǎng)景來(lái)決定.

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

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

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

最新評(píng)論