一、異常概述與異常體系結構

1. 異常概述

引入

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

概念

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

2. 分類

2.1 Error vs Exception

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

（1） Error

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

（2）Exception

其它因編程錯誤或偶然的外在因素導致的一般性問題，可以使用針對性的代碼進行處理。例如：

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

• 遇到錯誤就終止程序的運行。
• 由程序員在編寫程序時，就考慮到錯誤的檢測、錯誤消息的提示，以及錯誤的處理。

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

2.2 編譯時異常vs運行時異常

分類：編譯時異常和運行時異常

（1）編譯時異常

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

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

舉例：

• IOException（FileNotFoundException）
• ClassNotFoundException

（2）運行時異常

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

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

舉例：

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

注意： 捕獲錯誤最理想的是在編譯期間，但有的錯誤只有在運行時才會發(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();
}

二、異常處理機制

1. 概述

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

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

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

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

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

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

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

• try-catch-finally
• throws

（4）異常對象的生成 ：

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

• 由虛擬機自動生成：

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

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

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

2. 異常處理機制一之try-catch-finally

2.1 語法格式

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

2.2 使用

（1）try

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

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

③ 一旦try中的異常對象匹配到某一個catch時，就進入catch中進行異常的處理。

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

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

在try結構中聲明的變量，再出了try結構以后，就不能再被調用。

try-catch-finally結構可以嵌套。

（2）catch (Exceptiontype e)

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

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

與其它對象一樣，可以訪問一個異常對象的成員變量或調用它的方法。

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

（4）finally

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

2.3 代碼演示

//舉例一：
/*
例子一使用的異常都是RuntimeException類或是它的子類，這些類的異常的特點是：
即使沒有使用try和catch捕獲，Java自己也能捕獲，并且編譯通過(但運行時會發(fā)生異常使得程序運行終止)。
*/
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等類型的非運行時異常，則必須捕獲，否則
編譯錯誤。也就是說，我們必須處理編譯時異常，將異常進行捕捉，轉化為
運行時異常。
*/
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. 異常處理機制二之聲明拋出異常throws

3.1 語法格式

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

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

3.2 使用

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

（2）如果一個方法(中的語句執(zhí)行時)可能生成某種異常，但是并不能確定如何處理這種異常，則此方法應顯示地聲明拋出異常，表明該方法將不對這些異常進行處理，而由該方法的調用者負責處理。

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

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

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

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 { //報錯
……
} }

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

（1）性質：

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

（2）使用：

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

5. 手動拋出異常throw

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

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

IOException e = new IOException();

throw e;

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

6. 用戶自定義異常類

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

（2）自定義異常類通常需要編寫幾個重載的構造器。

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

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

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

（5）用戶自定義異常類MyException，用于描述數(shù)據(jù)取值范圍錯誤信息。用戶自己的異常類必須繼承現(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ù)為負值，不合理", 3);
            else
            System.out.println("登記人數(shù)" + num);
      }
      public void manager() {
            try {
                  regist(100);
            } catch (MyException e) {
                  System.out.print("登記失敗，出錯種類" +e.getId());
            }
            System.out.print("本次登記操作結束");
      }
      public static void main(String args[]) {
            MyExpTest t = new MyExpTest();
            t.manager();
      } 
}

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

最新評論