一、異常概述與異常體系結(jié)構(gòu)

1. 異常概述

引入

在使用計(jì)算機(jī)語言進(jìn)行項(xiàng)目開發(fā)的過程中，即使程序員把代碼寫得盡善盡美，在系統(tǒng)的運(yùn)行過程中仍然會(huì)遇到一些問題，因?yàn)楹芏鄦栴}不是靠代碼能夠避免的，比如：客戶輸入數(shù)據(jù)的格式，讀取文件是否存在，網(wǎng)絡(luò)是否始終保持通暢等等。

概念

在Java語言中，將程序執(zhí)行中發(fā)生的不正常情況稱為 “ 異常 ”。 (開發(fā)過程中的語法錯(cuò)誤和邏輯錯(cuò)誤不是異常)

2. 分類

2.1 Error vs Exception

Java程序在執(zhí)行過程中所發(fā)生的異常事件可分為兩類：

（1） Error

Java虛擬機(jī)無法解決的嚴(yán)重問題。如：JVM系統(tǒng)內(nèi)部錯(cuò)誤、資源耗盡等嚴(yán)重情況。比如：StackOverflowError和OOM。一般不編寫針對性的代碼進(jìn)行處理。

（2）Exception

其它因編程錯(cuò)誤或偶然的外在因素導(dǎo)致的一般性問題，可以使用針對性的代碼進(jìn)行處理。例如：

對于這些錯(cuò)誤，一般有兩種解決方法：

• 遇到錯(cuò)誤就終止程序的運(yùn)行。
• 由程序員在編寫程序時(shí)，就考慮到錯(cuò)誤的檢測、錯(cuò)誤消息的提示，以及錯(cuò)誤的處理。

注意：程序員通常只能處理Exception，而對Error無能為力。

2.2 編譯時(shí)異常vs運(yùn)行時(shí)異常

分類：編譯時(shí)異常和運(yùn)行時(shí)異常

（1）編譯時(shí)異常

編譯時(shí)異常是指編譯器要求必須處置的異常。即程序在運(yùn)行時(shí)由于外界因素造成的一般性異常。編譯器要求Java程序必須捕獲或聲明所有編譯時(shí)異常。

對于這類異常，如果程序不處理，可能會(huì)帶來意想不到的結(jié)果。

舉例：

• IOException（FileNotFoundException）
• ClassNotFoundException

（2）運(yùn)行時(shí)異常

運(yùn)行時(shí)異常是指編譯器不要求強(qiáng)制處置的異常。一般是指編程時(shí)的邏輯錯(cuò)誤，是程序員應(yīng)該積極避免其出現(xiàn)的異常。java.lang.RuntimeException類及它的子類都是運(yùn)行時(shí)異常。

對于這類異常，可以不作處理，因?yàn)檫@類異常很普遍，若全處理可能會(huì)對程序的可讀性和運(yùn)行效率產(chǎn)生影響。

舉例：

• NullPointerException
• ArrayIndexOutOfBoundsException
• ClassCastException
• NumberFormatException
• InputMismatchException
• ArithmeticException

注意： 捕獲錯(cuò)誤最理想的是在編譯期間，但有的錯(cuò)誤只有在運(yùn)行時(shí)才會(huì)發(fā)生。

3. 常見異常

3.1 分類

（1） java.lang.RuntimeException

• ClassCastException
• ArrayIndexOutOfBoundsException
• NullPointerException
• ArithmeticException
• NumberFormatException
• InputMismatchException
• …

（2） java.io.IOExeption

• FileNotFoundException
• EOFException

（3） java.lang.ClassNotFoundException

（4） java.lang.InterruptedException

（5） java.io.FileNotFoundException

（6） java.sql.SQLException

3.2 代碼演示

ClassCastException ：

public class Order {
    public static void main(String[] args) {
       Object obj = new Date();
       Order order;
       order = (Order) obj;
       System.out.println(order);
     } 
}

ArrayIndexOutOfBoundsException ：

public class IndexOutExp {
   public static void main(String[] args) {
      String friends[] = { "lisa", "bily", "kessy" };
      for (int i = 0; i < 5; i++) {
        System.out.println(friends[i]); // friends[4]?
      }
      System.out.println("\nthis is the end");
   } 
}

NullPointerException ：

public class NullRef {
   int i = 1;
   public static void main(String[] args) {
     NullRef t = new NullRef();
     t = null;
     System.out.println(t.i);
   } 
}

ArithmeticException ：

public class DivideZero {
   int x;
   public static void main(String[] args) {
      int y;
      DivideZero c=new DivideZero();
      y=3/c.x; 
      System.out.println("program ends ok!");
   } 
}

NumberFormatException ：

  public void test1(){		
		String str = "123";
		str = "abc";
		int num = Integer.parseInt(str);						
  }

InputMismatchException：

public void test1(){
		Scanner scanner = new Scanner(System.in);
		int score = scanner.nextInt();
		System.out.println(score);		
		scanner.close();
}

二、異常處理機(jī)制

1. 概述

（1）在編寫程序時(shí)，經(jīng)常要在可能出現(xiàn)錯(cuò)誤的地方加上檢測的代碼。

如進(jìn)行x/y運(yùn)算時(shí)，要檢測分母為0，數(shù)據(jù)為空，輸入的不是數(shù)據(jù)，而是字符等。過多的if-else分支會(huì)導(dǎo)致程序的代碼加長、臃腫、可讀性差。因此采用異常處理機(jī)制。

（2）Java采用的異常處理機(jī)制，是將異常處理的程序代碼集中在一起，與正常的程序代碼分開，使得程序簡潔、優(yōu)雅，并易于維護(hù)。

（3）Java提供的是異常處理的抓拋模型。

Java程序的執(zhí)行過程中如出現(xiàn)異常，會(huì)生成一個(gè)異常類對象，該異常對象將被提交給Java運(yùn)行時(shí)系統(tǒng)，這個(gè)過程稱為拋出(throw)異常。

過程一：“拋”：程序在正常執(zhí)行的過程中，一旦出現(xiàn)異常，就會(huì)在異常代碼處生成一個(gè)對應(yīng)異常類的對象。并將此對象拋出。一旦拋出對象以后，其后的代碼就不再執(zhí)行。

過程二：“抓”：可以理解為異常的處理方式：

• try-catch-finally
• throws

（4）異常對象的生成 ：

首先要生成異常類對象，然后通過throw語句實(shí)現(xiàn)拋出操作(提交給Java運(yùn)行環(huán)境)。

• 由虛擬機(jī)自動(dòng)生成：

程序運(yùn)行過程中，虛擬機(jī)檢測到程序發(fā)生了問題，如果在當(dāng)前代碼中沒有找到相應(yīng)的處理程序，就會(huì)在后臺自動(dòng)創(chuàng)建一個(gè)對應(yīng)異常類的實(shí)例對象并拋出——自動(dòng)拋出

• 由開發(fā)人員手動(dòng)創(chuàng)建：

Exception exception = new ClassCastException();——創(chuàng)建好的異常對象不拋出對程序沒有任何影響，和創(chuàng)建一個(gè)普通對象一樣。

2. 異常處理機(jī)制一之try-catch-finally

2.1 語法格式

 try{
        ...... //可能產(chǎn)生異常的代碼
    }
    catch( ExceptionName1 e ){
        ...... //當(dāng)產(chǎn)生ExceptionName1型異常時(shí)的處置措施
    }
    catch( ExceptionName2 e ){
        ...... //當(dāng)產(chǎn)生ExceptionName2型異常時(shí)的處置措施
    } finally{
    ...... //無論是否發(fā)生異常，都無條件執(zhí)行的語句
    } 

2.2 使用

（1）try

① 捕獲異常的第一步是用try{…}語句塊選定捕獲異常的范圍，將可能出現(xiàn)異常的代碼放在try語句塊中。

② 在執(zhí)行過程中，一旦出現(xiàn)異常，就會(huì)生成一個(gè)對應(yīng)異常類的對象，根據(jù)此對象的類型，去catch中進(jìn)行匹配。

③ 一旦try中的異常對象匹配到某一個(gè)catch時(shí)，就進(jìn)入catch中進(jìn)行異常的處理。

④ 一旦處理完成，就跳出當(dāng)前的 try-catch結(jié)構(gòu)（在沒有寫finally的情況），繼續(xù)執(zhí)行其后的代碼。

以上執(zhí)行步驟順序：① ==> ② ==> ③ ==> ④

在try結(jié)構(gòu)中聲明的變量，再出了try結(jié)構(gòu)以后，就不能再被調(diào)用。

try-catch-finally結(jié)構(gòu)可以嵌套。

（2）catch (Exceptiontype e)

• 在catch語句塊中是對異常對象進(jìn)行處理的代碼。
• 每個(gè)try語句塊可以伴隨一個(gè)或多個(gè)catch語句，用于處理可能產(chǎn)生的不同類型的異常對象。
• 如果明確知道產(chǎn)生的是何種異常，可以用該異常類作為catch的參數(shù)，也可以用其父類作為catch的參數(shù)。
• catch中的異常類型如果滿足子父類關(guān)系，則要求子類一定聲明在父類的上面。否則，報(bào)錯(cuò)。
• catch中的異常類型如果沒有滿足子父類關(guān)系，則誰聲明在上，誰聲明在下無所謂。比如：可以用 ArithmeticException 類作為參數(shù)的地方，就可以用RuntimeException類作為參數(shù)，或者用所有異常的父類Exception類作為參數(shù)。但不能是與ArithmeticException類無關(guān)的異常，如NullPointerException（catch中的語句將不會(huì)執(zhí)行）。

（3）捕獲異常的有關(guān)信息（寫在catch{ }語句中）：

與其它對象一樣，可以訪問一個(gè)異常對象的成員變量或調(diào)用它的方法。

• getMessage() 獲取異常信息，返回字符串 。
• printStackTrace() 獲取異常類名和異常信息，以及異常出 現(xiàn)在程序中的位置。返回值void。

（4）finally

• finally語句和catch語句是任選的。
• 不論在try代碼塊中是否發(fā)生了異常事件，catch語句是否執(zhí)行，catch語句是否有異常，catch語句中是否有return， finally塊中的語句都會(huì)被執(zhí)行。
• 捕獲異常的最后一步是通過finally語句為異常處理提供一個(gè)統(tǒng)一的出口，使得在控制流轉(zhuǎn)到程序的其它部分以前，能夠?qū)Τ绦虻臓顟B(tài)作統(tǒng)一的管理。

2.3 代碼演示

//舉例一：
/*
例子一使用的異常都是RuntimeException類或是它的子類，這些類的異常的特點(diǎn)是：
即使沒有使用try和catch捕獲，Java自己也能捕獲，并且編譯通過(但運(yùn)行時(shí)會(huì)發(fā)生異常使得程序運(yùn)行終止)。
*/
public class IndexOutExp {
    public static void main(String[] args) {
         String friends[] = { "lisa", "bily", "kessy" };
         try {
            for (int i = 0; i < 5; i++) {
                System.out.println(friends[i]);
            }
         } catch (ArrayIndexOutOfBoundsException e) {
             System.out.println("index err");
         }
          System.out.println("\nthis is the end");
    } 
}
/*     output：
             lisa
             bily
             kessy
             index err
             this is the end
*/

//舉例二：
/*
如果拋出的異常是IOException等類型的非運(yùn)行時(shí)異常，則必須捕獲，否則
編譯錯(cuò)誤。也就是說，我們必須處理編譯時(shí)異常，將異常進(jìn)行捕捉，轉(zhuǎn)化為
運(yùn)行時(shí)異常。
*/
public class IOExp {
    public static void main(String[] args) {
       FileInputStream in = new FileInputStream("atguigushk.txt");
       int b;
       b = in.read();
       while (b != -1) {
          System.out.print((char) b);
          b = in.read();
       }
          in.close();
    } 
}

3. 異常處理機(jī)制二之聲明拋出異常throws

3.1 語法格式

"throws + 異常類型"寫在方法的聲明處。指明此方法執(zhí)行時(shí)，可能會(huì)拋出的異常類型。

public void readFile(String file) throws FileNotFoundException {
    ……
    // 讀文件的操作可能產(chǎn)生FileNotFoundException類型的異常
    FileInputStream fis = new FileInputStream(file);
    ……
}

3.2 使用

（1）聲明拋出異常是Java中處理異常的第二種方式

（2）如果一個(gè)方法(中的語句執(zhí)行時(shí))可能生成某種異常，但是并不能確定如何處理這種異常，則此方法應(yīng)顯示地聲明拋出異常，表明該方法將不對這些異常進(jìn)行處理，而由該方法的調(diào)用者負(fù)責(zé)處理。

（3）在方法聲明中用throws語句可以聲明拋出異常的列表，throws后面的異常類型可以是方法中產(chǎn)生的異常類型，也可以是它的父類。

（4）一旦當(dāng)方法體執(zhí)行時(shí)，出現(xiàn)異常，仍會(huì)在異常代碼處生成一個(gè)異常類的對象，此對象滿足throws后的異常類型時(shí)，就會(huì)被拋出。異常代碼后續(xù)的代碼，就不再執(zhí)行！

（5）重寫方法不能拋出比被重寫方法范圍更大的異常類型。在多態(tài)的情況下， 對methodA()方法的調(diào)用-異常的捕獲按父類聲明的異常處理。

public class A {
public void methodA() throws IOException {
……
} }
public class B1 extends A {
public void methodA() throws FileNotFoundException {
……
} }
public class B2 extends A {
public void methodA() throws Exception { //報(bào)錯(cuò)
……
} }

4. try-catch-finally與throws的區(qū)別

（1）性質(zhì)：

• try-catch-finally:真正的將異常給處理掉了。
• throws的方式只是將異常拋給了方法的調(diào)用者，并沒有真正將異常處理掉。

（2）使用：

• 如果父類中被重寫的方法沒有throws方式處理異常，則子類重寫的方法也不能使用throws，意味著如果子類重寫的方法中有異常，必須使用try-catch-finally方式處理。
• 執(zhí)行的方法a中，先后又調(diào)用了另外的幾個(gè)方法，這幾個(gè)方法是遞進(jìn)關(guān)系執(zhí)行的。我們建議這幾個(gè)方法使用throws的方式進(jìn)行處理。而執(zhí)行的方法a可以考慮使用try-catch-finally方式進(jìn)行處理。

5. 手動(dòng)拋出異常throw

Java異常類對象除在程序執(zhí)行過程中出現(xiàn)異常時(shí)由系統(tǒng)自動(dòng)生成并拋出，也可根據(jù)需要使用人工創(chuàng)建并拋出。

首先要生成異常類對象，然后通過throw語句實(shí)現(xiàn)拋出操作(提交給Java運(yùn)行環(huán)境)。

IOException e = new IOException();

throw e;

可以拋出的異常必須是Throwable或其子類的實(shí)例。下面的語句在編譯時(shí)將 會(huì)產(chǎn)生語法錯(cuò)誤： throw new String("want to throw");

6. 用戶自定義異常類

（1）一般地，用戶自定義異常類都是RuntimeException的子類。

（2）自定義異常類通常需要編寫幾個(gè)重載的構(gòu)造器。

（3）自定義異常需要提供serialVersionUID 。

（3）自定義的異常通過throw拋出。

（4）自定義異常最重要的是異常類的名字，當(dāng)異常出現(xiàn)時(shí)，可以根據(jù)名字判斷異常類型。

（5）用戶自定義異常類MyException，用于描述數(shù)據(jù)取值范圍錯(cuò)誤信息。用戶自己的異常類必須繼承現(xiàn)有的異常類。

class MyException extends Exception {
      static final long serialVersionUID = 13465653435L;
      private int idnumber;
      public MyException(String message, int id) {
            super(message);
            this.idnumber = id; }
      public int getId() {
            return idnumber;       
      } 
}

public class MyExpTest {
      public void regist(int num) throws MyException {
            if (num < 0)
            throw new MyException("人數(shù)為負(fù)值，不合理", 3);
            else
            System.out.println("登記人數(shù)" + num);
      }
      public void manager() {
            try {
                  regist(100);
            } catch (MyException e) {
                  System.out.print("登記失敗，出錯(cuò)種類" +e.getId());
            }
            System.out.print("本次登記操作結(jié)束");
      }
      public static void main(String args[]) {
            MyExpTest t = new MyExpTest();
            t.manager();
      } 
}

到此這篇關(guān)于Java超詳細(xì)梳理異常處理機(jī)制的文章就介紹到這了,更多相關(guān)Java 異常處理內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論