Java中的異常和處理知識點總結

這篇文章主要介紹“Java中的異常和處理知識點總結”，在日常操作中，相信很多人在Java中的異常和處理知識點總結問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Java中的異常和處理知識點總結”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

創(chuàng)新互聯(lián)自2013年創(chuàng)立以來，是專業(yè)互聯(lián)網(wǎng)技術服務公司，擁有項目成都網(wǎng)站建設、網(wǎng)站設計網(wǎng)站策劃，項目實施與項目整合能力。我們以讓每一個夢想脫穎而出為使命，1280元赤峰做網(wǎng)站,已為上家服務,為赤峰各地企業(yè)和個人服務,聯(lián)系電話:18982081108

程序運行時，發(fā)生的不被期望的事件，它阻止了程序按照程序員的預期正常執(zhí)行，這就是異常。異常發(fā)生時，是任程序自生自滅，立刻退出終止，還是輸出錯誤給用戶?或者用C語言風格：用函數(shù)返回值作為執(zhí)行狀態(tài)。

Java提供了更加優(yōu)秀的解決辦法：異常處理機制。

異常處理機制能讓程序在異常發(fā)生時，按照代碼的預先設定的異常處理邏輯，針對性地處理異常，讓程序盡***可能恢復正常并繼續(xù)執(zhí)行，且保持代碼的清晰。

Java中的異常可以是函數(shù)中的語句執(zhí)行時引發(fā)的，也可以是程序員通過throw  語句手動拋出的，只要在Java程序中產(chǎn)生了異常，就會用一個對應類型的異常對象來封裝異常，JRE就會試圖尋找異常處理程序來處理異常。

Throwable類是Java異常類型的頂層父類，一個對象只有是 Throwable  類的(直接或者間接)實例，他才是一個異常對象，才能被異常處理機制識別。JDK中內建了一些常用的異常類，我們也可以自定義異常。

Java異常的分類和類結構圖

Java標準褲內建了一些通用的異常，這些類以Throwable為頂層父類。

Throwable又派生出Error類和Exception類。

錯誤：Error類以及他的子類的實例，代表了JVM本身的錯誤。錯誤不能被程序員通過代碼處理，Error很少出現(xiàn)。因此，程序員應該關注Exception為父類的分支下的各種異常類。

異常：Exception以及他的子類，代表程序運行時發(fā)送的各種不期望發(fā)生的事件?？梢员籎ava異常處理機制使用，是異常處理的核心。

總體上我們根據(jù)Javac對異常的處理要求，將異常類分為2類。

非檢查異常(unckecked exception)：Error 和 RuntimeException  以及他們的子類。javac在編譯時，不會提示和發(fā)現(xiàn)這樣的異常，不要求在程序處理這些異常。所以如果愿意，我們可以編寫代碼處理(使用try…catch…finally)這樣的異常，也可以不處理。對于這些異常，我們應該修正代碼，而不是去通過異常處理器處理  。這樣的異常發(fā)生的原因多半是代碼寫的有問題。如除0錯誤ArithmeticException，錯誤的強制類型轉換錯誤ClassCastException，數(shù)組索引越界ArrayIndexOutOfBoundsException，使用了空對象NullPointerException等等。

檢查異常(checked exception)：除了Error 和  RuntimeException的其它異常。javac強制要求程序員為這樣的異常做預備處理工作(使用try…catch…finally或者throws)。在方法中要么用try-catch語句捕獲它并處理，要么用throws子句聲明拋出它，否則編譯不會通過。這樣的異常一般是由程序的運行環(huán)境導致的。因為程序可能被運行在各種未知的環(huán)境下，而程序員無法干預用戶如何使用他編寫的程序，于是程序員就應該為這樣的異常時刻準備著。如SQLException  , IOException,ClassNotFoundException 等。

需要明確的是：檢查和非檢查是對于javac來說的，這樣就很好理解和區(qū)分了。

初識異常

下面的代碼會演示2個異常類型：ArithmeticException 和  InputMismatchException。前者由于整數(shù)除0引發(fā)，后者是輸入的數(shù)據(jù)不能被轉換為int類型引發(fā)。

package com.example; import java. util .Scanner ; public class AllDemo {       public static void main (String [] args )       {             System . out. println( "----歡迎使用命令行除法計算器----" ) ;             CMDCalculate ();       }       public static void CMDCalculate ()       {             Scanner scan = new Scanner ( System. in );             int num1 = scan .nextInt () ;             int num2 = scan .nextInt () ;             int result = devide (num1 , num2 ) ;             System . out. println( "result:" + result) ;             scan .close () ;       }       public static int devide (int num1, int num2 ){             return num1 / num2 ;       } } /*****************************************   ----歡迎使用命令行除法計算器---- 0 Exception in thread "main" java.lang.ArithmeticException : / by zero      at com.example.AllDemo.devide( AllDemo.java:30 )      at com.example.AllDemo.CMDCalculate( AllDemo.java:22 )      at com.example.AllDemo.main( AllDemo.java:12 )   ----歡迎使用命令行除法計算器---- r Exception in thread "main" java.util.InputMismatchException      at java.util.Scanner.throwFor( Scanner.java:864 )      at java.util.Scanner.next( Scanner.java:1485 )      at java.util.Scanner.nextInt( Scanner.java:2117 )      at java.util.Scanner.nextInt( Scanner.java:2076 )      at com.example.AllDemo.CMDCalculate( AllDemo.java:20 )      at com.example.AllDemo.main( AllDemo.java:12 ) *****************************************/

異常是在執(zhí)行某個函數(shù)時引發(fā)的，而函數(shù)又是層級調用，形成調用棧的，因為，只要一個函數(shù)發(fā)生了異常，那么他的所有的caller都會被異常影響。當這些被影響的函數(shù)以異常信息輸出時，就形成的了異常追蹤棧。

異常***發(fā)生的地方，叫做異常拋出點。

從上面的例子可以看出，當devide函數(shù)發(fā)生除0異常時，devide函數(shù)將拋出ArithmeticException異常，因此調用他的CMDCalculate函數(shù)也無法正常完成，因此也發(fā)送異常，而CMDCalculate的caller——main  因為CMDCalculate拋出異常，也發(fā)生了異常，這樣一直向調用棧的棧底回溯。這種行為叫做異常的冒泡，異常的冒泡是為了在當前發(fā)生異常的函數(shù)或者這個函數(shù)的caller中找到最近的異常處理程序。由于這個例子中沒有使用任何異常處理機制，因此異常最終由main函數(shù)拋給JRE，導致程序終止。

上面的代碼不使用異常處理機制，也可以順利編譯，因為2個異常都是非檢查異常。但是下面的例子就必須使用異常處理機制，因為異常是檢查異常。

代碼中我選擇使用throws聲明異常，讓函數(shù)的調用者去處理可能發(fā)生的異常。但是為什么只throws了IOException呢?因為FileNotFoundException是IOException的子類，在處理范圍內。

@Test public void testException() throws IOException {     //FileInputStream的構造函數(shù)會拋出FileNotFoundException     FileInputStream fileIn = new FileInputStream("E:\a.txt");           int word;     //read方法會拋出IOException     while((word =  fileIn.read())!=-1)      {         System.out.print((char)word);     }     //close方法會拋出IOException     fileIn.clos }

異常處理的基本語法

在編寫代碼處理異常時，對于檢查異常，有2種不同的處理方式：使用try…catch…finally語句塊處理它?；蛘撸诤瘮?shù)簽名中使用throws  聲明交給函數(shù)調用者caller去解決。

try…catch…finally語句塊

try{      //try塊中放可能發(fā)生異常的代碼。      //如果執(zhí)行完try且不發(fā)生異常，則接著去執(zhí)行finally塊和finally后面的代碼（如果有的話）。      //如果發(fā)生異常，則嘗試去匹配catch塊。   }catch(SQLException SQLexception){     //每一個catch塊用于捕獲并處理一個特定的異常，或者這異常類型的子類。Java7中可以將多個異常聲明在一個catch中。     //catch后面的括號定義了異常類型和異常參數(shù)。如果異常與之匹配且是***匹配到的，則虛擬機將使用這個catch塊來處理異常。     //在catch塊中可以使用這個塊的異常參數(shù)來獲取異常的相關信息。異常參數(shù)是這個catch塊中的局部變量，其它塊不能訪問。     //如果當前try塊中發(fā)生的異常在后續(xù)的所有catch中都沒捕獲到，則先去執(zhí)行finally，然后到這個函數(shù)的外部caller中去匹配異常處理器。     //如果try中沒有發(fā)生異常，則所有的catch塊將被忽略。   }catch(Exception exception){     //... }finally{          //finally塊通常是可選的。    //無論異常是否發(fā)生，異常是否匹配被處理，finally都會執(zhí)行。    //一個try至少要有一個catch塊，否則， 至少要有1個finally塊。但是finally不是用來處理異常的，finally不會捕獲異常。   //finally主要做一些清理工作，如流的關閉，數(shù)據(jù)庫連接的關閉等。  }

需要注意的地方

1、try塊中的局部變量和catch塊中的局部變量(包括異常變量)，以及finally中的局部變量，他們之間不可共享使用。

2、每一個catch塊用于處理一個異常。異常匹配是按照catch塊的順序從上往下尋找的，只有***個匹配的catch會得到執(zhí)行。匹配時，不僅運行精確匹配，也支持父類匹配，因此，如果同一個try塊下的多個catch異常類型有父子關系，應該將子類異常放在前面，父類異常放在后面，這樣保證每個catch塊都有存在的意義。

3、java中，異常處理的任務就是將執(zhí)行控制流從異常發(fā)生的地方轉移到能夠處理這種異常的地方去。也就是說：當一個函數(shù)的某條語句發(fā)生異常時，這條語句的后面的語句不會再執(zhí)行，它失去了焦點。執(zhí)行流跳轉到最近的匹配的異常處理catch代碼塊去執(zhí)行，異常被處理完后，執(zhí)行流會接著在“處理了這個異常的catch代碼塊”后面接著執(zhí)行。

有的編程語言當異常被處理后，控制流會恢復到異常拋出點接著執(zhí)行，這種策略叫做：resumption model of exception  handling(恢復式異常處理模式 )

而Java則是讓執(zhí)行流恢復到處理了異常的catch塊后接著執(zhí)行，這種策略叫做：termination model of exception  handling(終結式異常處理模式)

public static void main(String[] args){         try {             foo();         }catch(ArithmeticException ae) {             System.out.println("處理異常");         } } public static void foo(){         int a = 5/0;  //異常拋出點         System.out.println("為什么還不給我漲工資!!!");  //////////////////////不會執(zhí)行 }

throws 函數(shù)聲明

throws聲明：如果一個方法內部的代碼會拋出檢查異常(checked  exception)，而方法自己又沒有完全處理掉，則javac保證你必須在方法的簽名上使用throws關鍵字聲明這些可能拋出的異常，否則編譯不通過。

throws是另一種處理異常的方式，它不同于try…catch…finally，throws僅僅是將函數(shù)中可能出現(xiàn)的異常向調用者聲明，而自己則不具體處理。

采取這種異常處理的原因可能是：方法本身不知道如何處理這樣的異常，或者說讓調用者處理更好，調用者需要為可能發(fā)生的異常負責。

public void foo() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN {       //foo內部可以拋出 ExceptionType1 , ExceptionType2 ,ExceptionTypeN 類的異常，或者他們的子類的異常對象。 }

finally塊

finally塊不管異常是否發(fā)生，只要對應的try執(zhí)行了，則它一定也執(zhí)行。只有一種方法讓finally塊不執(zhí)行：System.exit()。因此finally塊通常用來做資源釋放操作：關閉文件，關閉數(shù)據(jù)庫連接等等。

良好的編程習慣是：在try塊中打開資源，在finally塊中清理釋放這些資源。

需要注意的地方:

1、finally塊沒有處理異常的能力。處理異常的只能是catch塊。

2、在同一try…catch…finally塊中  ，如果try中拋出異常，且有匹配的catch塊，則先執(zhí)行catch塊，再執(zhí)行finally塊。如果沒有catch塊匹配，則先執(zhí)行finally，然后去外面的調用者中尋找合適的catch塊。

3、在同一try…catch…finally塊中  ，try發(fā)生異常，且匹配的catch塊中處理異常時也拋出異常，那么后面的finally也會執(zhí)行：首先執(zhí)行finally塊，然后去外圍調用者中尋找合適的catch塊。

這是正常的情況，但是也有特例。關于finally有很多惡心，偏、怪、難的問題，我在本文***統(tǒng)一介紹了，電梯速達->：finally塊和return

throw 異常拋出語句

throw exceptionObject

程序員也可以通過throw語句手動顯式的拋出一個異常。throw語句的后面必須是一個異常對象。

throw 語句必須寫在函數(shù)中，執(zhí)行throw 語句的地方就是一個異常拋出點，它和由JRE自動形成的異常拋出點沒有任何差別。

public void save(User user) {       if(user  == null)            throw new IllegalArgumentException("User對象為空");       //......           }

異常的鏈化

在一些大型的，模塊化的軟件開發(fā)中，一旦一個地方發(fā)生異常，則如骨牌效應一樣，將導致一連串的異常。假設B模塊完成自己的邏輯需要調用A模塊的方法，如果A模塊發(fā)生異常，則B也將不能完成而發(fā)生異常，但是B在拋出異常時，會將A的異常信息掩蓋掉，這將使得異常的根源信息丟失。異常的鏈化可以將多個模塊的異常串聯(lián)起來，使得異常信息不會丟失。

異常鏈化:以一個異常對象為參數(shù)構造新的異常對象。新的異對象將包含先前異常的信息。這項技術主要是異常類的一個帶Throwable參數(shù)的函數(shù)來實現(xiàn)的。這個當做參數(shù)的異常，我們叫他根源異常(cause)。

查看Throwable類源碼，可以發(fā)現(xiàn)里面有一個Throwable字段cause，就是它保存了構造時傳遞的根源異常參數(shù)。這種設計和鏈表的結點類設計如出一轍，因此形成鏈也是自然的了。

public class Throwable implements Serializable {     private Throwable cause = this;          public Throwable(String message, Throwable cause) {         fillInStackTrace();         detailMessage = message;         this.cause = cause;     }      public Throwable(Throwable cause) {         fillInStackTrace();         detailMessage = (cause==null ? null : cause.toString());         this.cause = cause;     }           //........ }

下面是一個例子，演示了異常的鏈化：從命令行輸入2個int，將他們相加，輸出。輸入的數(shù)不是int，則導致getInputNumbers異常，從而導致add函數(shù)異常，則可以在add函數(shù)中拋出

一個鏈化的異常。

public static void main(String[] args) {           System.out.println("請輸入2個加數(shù)");     int result;     try     {         result = add();         System.out.println("結果:"+result);     } catch (Exception e){         e.printStackTrace();     } } //獲取輸入的2個整數(shù)返回 private static List<Integer> getInputNumbers() {     List<Integer> nums = new ArrayList<>();     Scanner scan = new Scanner(System.in);     try {         int num1 = scan.nextInt();         int num2 = scan.nextInt();         nums.add(new Integer(num1));         nums.add(new Integer(num2));     }catch(InputMismatchException immExp){         throw immExp;     }finally {         scan.close();     }     return nums; }   //執(zhí)行加法計算 private static int add() throws Exception {     int result;     try {         List<Integer> nums =getInputNumbers();         result = nums.get(0)  + nums.get(1);     }catch(InputMismatchException immExp){         throw new Exception("計算失敗",immExp);  /////////////////////////////鏈化:以一個異常對象為參數(shù)構造新的異常對象。     }     return  result; }   /* 請輸入2個加數(shù) r 1 java.lang.Exception: 計算失敗     at practise.ExceptionTest.add(ExceptionTest.java:53)     at practise.ExceptionTest.main(ExceptionTest.java:18) Caused by: java.util.InputMismatchException     at java.util.Scanner.throwFor(Scanner.java:864)     at java.util.Scanner.next(Scanner.java:1485)     at java.util.Scanner.nextInt(Scanner.java:2117)     at java.util.Scanner.nextInt(Scanner.java:2076)     at practise.ExceptionTest.getInputNumbers(ExceptionTest.java:30)     at practise.ExceptionTest.add(ExceptionTest.java:48)     ... 1 more   */

自定義異常

如果要自定義異常類，則擴展Exception類即可，因此這樣的自定義異常都屬于檢查異常(checked  exception)。如果要自定義非檢查異常，則擴展自RuntimeException。

按照國際慣例，自定義的異常應該總是包含如下的構造函數(shù)：

• 一個無參構造函數(shù)

• 一個帶有String參數(shù)的構造函數(shù)，并傳遞給父類的構造函數(shù)。

• 一個帶有String參數(shù)和Throwable參數(shù)，并都傳遞給父類構造函數(shù)

• 一個帶有Throwable 參數(shù)的構造函數(shù)，并傳遞給父類的構造函數(shù)。

下面是IOException類的完整源代碼，可以借鑒。

public class IOException extends Exception {     static final long serialVersionUID = 7818375828146090155L;       public IOException()     {         super();     }       public IOException(String message)     {         super(message);     }       public IOException(String message, Throwable cause)     {         super(message, cause);     }             public IOException(Throwable cause)     {         super(cause);     } }

異常的注意事項

1、當子類重寫父類的帶有  throws聲明的函數(shù)時，其throws聲明的異常必須在父類異常的可控范圍內——用于處理父類的throws方法的異常處理器，必須也適用于子類的這個帶throws方法  。這是為了支持多態(tài)。

例如，父類方法throws 的是2個異常，子類就不能throws 3個及以上的異常。父類throws IOException，子類就必須throws  IOException或者IOException的子類。

至于為什么?我想，也許下面的例子可以說明。

class Father {     public void start() throws IOException     {         throw new IOException();     } }   class Son extends Father {     public void start() throws Exception     {         throw new SQLException();     } } /**********************假設上面的代碼是允許的（實質是錯誤的）***********************/ class Test {     public static void main(String[] args)     {         Father[] objs = new Father[2];         objs[0] = new Father();         objs[1] = new Son();           for(Father obj:objs)         {         //因為Son類拋出的實質是SQLException，而IOException無法處理它。         //那么這里的try。。catch就不能處理Son中的異常。         //多態(tài)就不能實現(xiàn)了。             try {                  obj.start();             }catch(IOException)             {                  //處理IOException             }          }    } }

2、Java程序可以是多線程的。每一個線程都是一個獨立的執(zhí)行流，獨立的函數(shù)調用棧。如果程序只有一個線程，那么沒有被任何代碼處理的異常  會導致程序終止。如果是多線程的，那么沒有被任何代碼處理的異常僅僅會導致異常所在的線程結束。

也就是說，Java中的異常是線程獨立的，線程的問題應該由線程自己來解決，而不要委托到外部，也不會直接影響到其它線程的執(zhí)行。

finally塊和return

首先一個不容易理解的事實：在 try塊中即便有return，break，continue等改變執(zhí)行流的語句，finally也會執(zhí)行。

public static void main(String[] args) {     int re = bar();     System.out.println(re); } private static int bar()  {     try{         return 5;     } finally{         System.out.println("finally");     } } /*輸出： finally */

很多人面對這個問題時，總是在歸納執(zhí)行的順序和規(guī)律，不過我覺得還是很難理解。我自己總結了一個方法。用如下GIF圖說明。

也就是說：try…catch…finally中的return  只要能執(zhí)行，就都執(zhí)行了，他們共同向同一個內存地址(假設地址是0×80)寫入返回值，后執(zhí)行的將覆蓋先執(zhí)行的數(shù)據(jù)，而真正被調用者取的返回值就是***一次寫入的。那么，按照這個思想，下面的這個例子也就不難理解了。

finally中的return 會覆蓋 try 或者catch中的返回值。

public static void main(String[] args)     {         int result;                   result  =  foo();         System.out.println(result);     /////////2                   result = bar();         System.out.println(result);    /////////2     }       @SuppressWarnings("finally")     public static int foo()     {         trz{             int a = 5 / 0;         } catch (Exception e){             return 1;         } finally{             return 2;         }       }       @SuppressWarnings("finally")     public static int bar()     {         try {             return 1;         }finally {             return 2;         }     }

finally中的return會抑制(消滅)前面try或者catch塊中的異常

class TestException {     public static void main(String[] args)     {         int result;         try{             result = foo();             System.out.println(result);           //輸出100         } catch (Exception e){             System.out.println(e.getMessage());    //沒有捕獲到異常         }                             try{             result  = bar();             System.out.println(result);           //輸出100         } catch (Exception e){             System.out.println(e.getMessage());    //沒有捕獲到異常         }     }           //catch中的異常被抑制     @SuppressWarnings("finally")     public static int foo() throws Exception     {         try {             int a = 5/0;             return 1;         }catch(ArithmeticException amExp) {             throw new Exception("我將被忽略，因為下面的finally中使用了return");         }finally {             return 100;         }     }           //try中的異常被抑制     @SuppressWarnings("finally")     public static int bar() throws Exception     {         try {             int a = 5/0;             return 1;         }finally {             return 100;         }     } }

finally中的異常會覆蓋(消滅)前面try或者catch中的異常

class TestException {     public static void main(String[] args)     {         int result;         try{             result = foo();         } catch (Exception e){             System.out.println(e.getMessage());    //輸出：我是finaly中的Exception         }                             try{             result  = bar();         } catch (Exception e){             System.out.println(e.getMessage());    //輸出：我是finaly中的Exception         }     }           //catch中的異常被抑制     @SuppressWarnings("finally")     public static int foo() throws Exception     {         try {             int a = 5/0;             return 1;         }catch(ArithmeticException amExp) {             throw new Exception("我將被忽略，因為下面的finally中拋出了新的異常");         }finally {             throw new Exception("我是finaly中的Exception");         }     }           //try中的異常被抑制     @SuppressWarnings("finally")     public static int bar() throws Exception     {         try {             int a = 5/0;             return 1;         }finally {             throw new Exception("我是finaly中的Exception");         }               } }

上面的3個例子都異于常人的編碼思維，因此我建議：

• 不要在fianlly中使用return。

• 不要在finally中拋出異常。

• 減輕finally的任務，不要在finally中做一些其它的事情，finally塊僅僅用來釋放資源是最合適的。

• 將盡量將所有的return寫在函數(shù)的***面，而不是try … catch … finally中。 

到此，關于“Java中的異常和處理知識點總結”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續(xù)學習更多相關知識，請繼續(xù)關注創(chuàng)新互聯(lián)網(wǎng)站，小編會繼續(xù)努力為大家?guī)砀鄬嵱玫奈恼拢?/p>

當前文章：Java中的異常和處理知識點總結
當前地址：http://bm7419.com/article8/gijpip.html

成都網(wǎng)站建設公司_創(chuàng)新互聯(lián)，為您提供品牌網(wǎng)站設計、品牌網(wǎng)站建設、做網(wǎng)站、品牌網(wǎng)站制作、搜索引擎優(yōu)化、網(wǎng)站建設

廣告

聲明：本網(wǎng)站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經(jīng)允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)