av激情亚洲男人的天堂国语,日韩欧美精品一中文字幕,无码av一区二区三区无码,国产又色又爽又刺激的a片,国产又色又爽又刺激的a片

深入探討Java中的異常與錯誤處理

Java中的異常處理機(jī)制已經(jīng)比較成熟，我們的Java程序到處充滿了異常的可能，如果對這些異常不做預(yù)先的處理，那么將來程序崩潰就無從調(diào)試，很難找到異常所在的位置。本文將探討一下Java中異常與錯誤的處理方法，一起來看看。

10年積累的成都網(wǎng)站制作、成都網(wǎng)站建設(shè)經(jīng)驗，可以快速應(yīng)對客戶對網(wǎng)站的新想法和需求。提供各種問題對應(yīng)的解決方案。讓選擇我們的客戶得到更好、更有力的網(wǎng)絡(luò)服務(wù)。我雖然不認(rèn)識你，你也不認(rèn)識我。但先網(wǎng)站設(shè)計制作后付款的網(wǎng)站建設(shè)流程，更有平定免費網(wǎng)站建設(shè)讓你可以放心的選擇與我們合作。

異常與錯誤：

異常：

在Java中程序的錯誤主要是語法錯誤和語義錯誤，一個程序在編譯和運(yùn)行時出現(xiàn)的錯誤我們統(tǒng)一稱之為異常，它是VM(虛擬機(jī))通知你的一種方式，通過這種方式，VM讓你知道，你(開發(fā)人員)已經(jīng)犯了個錯誤，現(xiàn)在有一個機(jī)會來修改它。Java中使用異常類來表示異常，不同的異常類代表了不同的異常。但是在Java中所有的異常都有一個基類，叫做Exception。

錯誤：

它指的是一個合理的應(yīng)用程序不能截獲的嚴(yán)重的問題。大多數(shù)都是反常的情況。錯誤是VM的一個故障(雖然它可以是任何系統(tǒng)級的服務(wù))。所以，錯誤是很難處理的，一般的開發(fā)人員(當(dāng)然不是你)是無法處理這些錯誤的，比如內(nèi)存溢出。 和異常一樣，在Java中用錯誤類來表示錯誤，不同的錯誤類代表了不同的錯誤。 但是在Java中所有的錯誤都有一個基類，叫做Error。

綜上，我們可以知道異常和錯誤最本質(zhì)的區(qū)別就是異常能被開發(fā)人員處理而錯誤時系統(tǒng)本來自帶的，一般無法處理也不需要我們程序員來處理。

1.一個異常是在一個程序執(zhí)行過程中出現(xiàn)的一個事件，它中斷了正常指令的運(yùn)行

2.錯誤，偏離了可接受的代碼行為的一個動作或?qū)嵗?/p>

異常的結(jié)構(gòu)分類：

1、運(yùn)行時異常(未檢查異常)

2、編譯時異常(已檢查異常)

運(yùn)行異常即是RuntimeException;其余的全部為編譯異常

在Java中異常Exception和錯誤Error有個共同的父類Throwable。

Error Exception

runtimeException幾個子類

1、 java.lang.ArrayIndexOutOfBoundsException

數(shù)組索引越界異常。當(dāng)對數(shù)組的索引值為負(fù)數(shù)或大于等于數(shù)組大小時拋出。

2、java.lang.ArithmeticException

算術(shù)條件異常。譬如：整數(shù)除零等。

3、java.lang.NullPointerException

空指針異常。當(dāng)應(yīng)用試圖在要求使用對象的地方使用了null時，拋出該異常。譬如：調(diào)用null對象的實例方法、訪問null對象的

屬性、計算null對象的長度、使用throw語句拋出null等等

4、java.lang.ClassNotFoundException

找不到類異常。當(dāng)應(yīng)用試圖根據(jù)字符串形式的類名構(gòu)造類，而在遍歷CLASSPAH之后找不到對應(yīng)名稱的class文件時，拋出

該異常。

對異常的處理：

try{}catch{}

try{}catch{}finally{}無論有無異常finally代碼塊都會被執(zhí)行

try{}finally{}也是可以組合使用的但是catch{}finally{}不可以

注意：在繼承關(guān)系中，子類覆蓋父類的方法，拋出異常的范圍不能比父類更寬泛

異常的使用

在異常的使用這一部分主要是演示代碼，都是我們平常寫代碼的過程中會遇到的(當(dāng)然只是一小部分)，拋磚引玉嗎!

例1. 這個例子主要通過兩個方法對比來演示一下有了異常以后代碼的執(zhí)行流程。

 
 
 
      
  
  
  1. public static void testException1() { 
    2.   
  
  
  2.      int[] ints = new int[] { 1, 2, 3, 4 }; 
    3.   
  
  
  3.      System.out.println("異常出現(xiàn)前"); 
    4.   
  
  
  4.      try { 
    5.   
  
  
  5.           System.out.println(ints[4]); 
    6.   
  
  
  6.           System.out.println("我還有幸執(zhí)行到嗎");// 發(fā)生異常以后，后面的代碼不能被執(zhí)行 
    7.   
  
  
  7.      } catch (IndexOutOfBoundsException e) { 
    8.   
  
  
  8.           System.out.println("數(shù)組越界錯誤"); 
    9.   
  
  
  9.      } 
    10.   
  
  
  10.      System.out.println("異常出現(xiàn)后"); 
    11.   
  
  
  11. } 
    12.   
  
  
  12.  
    13.   
  
  
  13. /*output: 
    14.   
  
  
  14. 異常出現(xiàn)前 
    15.   
  
  
  15. 數(shù)組越界錯誤 
    16.   
  
  
  16. 常出現(xiàn)后 
    17.   
  
  
  17. */ 
    18.   
  
  
  18.  
    19.   
  
  
  19. public static void testException2() { 
    20.   
  
  
  20.      int[] ints = new int[] { 1, 2, 3, 4 }; 
    21.   
  
  
  21.      System.out.println("異常出現(xiàn)前"); 
    22.   
  
  
  22.      System.out.println(ints[4]); 
    23.   
  
  
  23.      System.out.println("我還有幸執(zhí)行到嗎");// 發(fā)生異常以后，他后面的代碼不能被執(zhí)行 
    24.   
  
  
  24. }  
    25.

首先指出例子中的不足之處，IndexOutofBoundsException是一個非受檢異常，所以不用try…catch…顯示捕捉，但是我的目的是對同一個異常用不同的處理方式，看它會有什么不同的而結(jié)果(這里也就只能用它將就一下了)。異常出現(xiàn)時***個方法只是跳出了try塊，但是它后面的代碼會照樣執(zhí)行的。但是第二種就不一樣了直接跳出了方法，比較強(qiáng)硬。從***個方法中我們看到，try…catch…是一種”事務(wù)性”的保障，它的目的是保證程序在異常的情況下運(yùn)行完畢，同時它還會告知程序員程序中出錯的詳細(xì)信息(這種詳細(xì)信息有時要依賴于程序員設(shè)計)。

例2. 重新拋出異常

 
 
 
      
  
  
  1. public class Rethrow { 
    2.   
  
  
  2.      public static void readFile(String file) throws FileNotFoundException { 
    3.   
  
  
  3.      try { 
    4.   
  
  
  4.           BufferedInputStream in = new BufferedInputStream(new FileInputStream(file)); 
    5.   
  
  
  5.      } catch (FileNotFoundException e) { 
    6.   
  
  
  6.           e.printStackTrace(); 
    7.   
  
  
  7.           System.err.println("不知道如何處理該異?；蛘吒静幌胩幚硭?，但是不做處理又不合適，這是重新拋出異常交給上一級處理"); 
    8.   
  
  
  8.           //重新拋出異常 
    9.   
  
  
  9.           throw e; 
    10.   
  
  
  10.      } 
    11.   
  
  
  11. } 
    12.   
  
  
  12. public static void printFile(String file) { 
    13.   
  
  
  13.      try { 
    14.   
  
  
  14.           readFile(file); 
    15.   
  
  
  15.      } catch (FileNotFoundException e) { 
    16.   
  
  
  16.           e.printStackTrace(); 
    17.   
  
  
  17.      } 
    18.   
  
  
  18. } 
    19.   
  
  
  19.      public static void main(String[] args) { 
    20.   
  
  
  20.           printFile("D:/file"); 
    21.   
  
  
  21.      } 
    22.   
  
  
  22. }  
    23.

異常的本意是好的，讓我們試圖修復(fù)程序，但是現(xiàn)實中我們修復(fù)的幾率很小，我們很多時候就是用它來記錄出錯的信息。如果你厭倦了不停的處理異常，重新拋出異常對你來說可能是一個很好的解脫。原封不動的把這個異常拋給上一級，拋給調(diào)用這個方法的人，讓他來費腦筋吧。這樣看來，java異常(當(dāng)然指的是受檢異常)又給我們平添很多麻煩，盡管它的出發(fā)點是好的。

例3. 異常鏈的使用及異常丟失

 
 
 
      
  
  
  1. ExceptionA,ExceptionB,ExceptionC 
    2.   
  
  
  2. public class ExceptionA extends Exception { 
    3.   
  
  
  3.      public ExceptionA(String str) { 
    4.   
  
  
  4.           super(); 
    5.   
  
  
  5.      } 
    6.   
  
  
  6. } 
    7.   
  
  
  7. public class ExceptionB extends ExceptionA { 
    8.   
  
  
  8.      public ExceptionB(String str) { 
    9.   
  
  
  9.           super(str); 
    10.   
  
  
  10.      } 
    11.   
  
  
  11. } 
    12.   
  
  
  12. public class ExceptionC extends ExceptionA { 
    13.   
  
  
  13.      public ExceptionC(String str) { 
    14.   
  
  
  14.           super(str); 
    15.   
  
  
  15.      } 
    16.   
  
  
  16. }  
    17.

異常丟失的情況：

 
 
 
      
  
  
  1. public class NeverCaught { 
    2.   
  
  
  2.      static void f() throws ExceptionB{ 
    3.   
  
  
  3.           throw new ExceptionB("exception b"); 
    4.   
  
  
  4.      } 
    5.   
  
  
  5.      static void g() throws ExceptionC { 
    6.   
  
  
  6.           try { 
    7.   
  
  
  7.                f(); 
    8.   
  
  
  8.           } catch (ExceptionB e) { 
    9.   
  
  
  9.                ExceptionC c = new ExceptionC("exception a"); 
    10.   
  
  
  10.                throw c; 
    11.   
  
  
  11.           } 
    12.   
  
  
  12.      } 
    13.   
  
  
  13.      public static void main(String[] args) { 
    14.   
  
  
  14.           try { 
    15.   
  
  
  15.                g(); 
    16.   
  
  
  16.           } catch (ExceptionC e) { 
    17.   
  
  
  17.                e.printStackTrace(); 
    18.   
  
  
  18.           } 
    19.   
  
  
  19.      } 
    20.   
  
  
  20. } 
    21.   
  
  
  21. /* 
    22.   
  
  
  22. exception.ExceptionC 
    23.   
  
  
  23. at exception.NeverCaught.g(NeverCaught.java:12) 
    24.   
  
  
  24. at exception.NeverCaught.main(NeverCaught.java:19) 
    25.   
  
  
  25. */  
    26.

為什么只是打印出來了ExceptionC而沒有打印出ExceptionB呢?這個還是自己分析一下吧!

上面的情況相當(dāng)于少了一種異常，這在我們排錯的過程中非常的不利。那我們遇到上面的情況應(yīng)該怎么辦呢?這就是異常鏈的用武之地：保存異常信息，在拋出另外一個異常的同時不丟失原來的異常。

 
 
 
      
  
  
  1. public class NeverCaught { 
    2.   
  
  
  2.      static void f() throws ExceptionB{ 
    3.   
  
  
  3.            throw new ExceptionB("exception b"); 
    4.   
  
  
  4.      } 
    5.   
  
  
  5.      static void g() throws ExceptionC { 
    6.   
  
  
  6.           try { 
    7.   
  
  
  7.                 f(); 
    8.   
  
  
  8.           } catch (ExceptionB e) { 
    9.   
  
  
  9.                 ExceptionC c = new ExceptionC("exception a"); 
    10.   
  
  
  10.                 //異常連 
    11.   
  
  
  11.                 c.initCause(e); 
    12.   
  
  
  12.                 throw c; 
    13.   
  
  
  13.           } 
    14.   
  
  
  14.      } 
    15.   
  
  
  15.      public static void main(String[] args) { 
    16.   
  
  
  16.           try { 
    17.   
  
  
  17.                 g(); 
    18.   
  
  
  18.           } catch (ExceptionC e) { 
    19.   
  
  
  19.                 e.printStackTrace(); 
    20.   
  
  
  20.           } 
    21.   
  
  
  21.      } 
    22.   
  
  
  22. } 
    23.   
  
  
  23. /* 
    24.   
  
  
  24. exception.ExceptionC 
    25.   
  
  
  25. at exception.NeverCaught.g(NeverCaught.java:12) 
    26.   
  
  
  26. at exception.NeverCaught.main(NeverCaught.java:21) 
    27.   
  
  
  27. Caused by: exception.ExceptionB 
    28.   
  
  
  28. at exception.NeverCaught.f(NeverCaught.java:5) 
    29.   
  
  
  29. at exception.NeverCaught.g(NeverCaught.java:10) 
    30.   
  
  
  30. ... 1 more 
    31.   
  
  
  31. */  
    32.

這個異常鏈的特性是所有異常均具備的，因為這個initCause()方法是從Throwable繼承的。

例4. 清理工作

清理工作對于我們來說是必不可少的，因為如果一些消耗資源的操作，比如IO,JDBC。如果我們用完以后沒有及時正確的關(guān)閉，那后果會很嚴(yán)重，這意味著內(nèi)存泄露。異常的出現(xiàn)要求我們必須設(shè)計一種機(jī)制不論什么情況下，資源都能及時正確的清理。這就是finally。

 
 
 
      
  
  
  1. public void readFile(String file) { 
    2.   
  
  
  2.      BufferedReader reader = null; 
    3.   
  
  
  3.      try { 
    4.   
  
  
  4.            reader = new BufferedReader(new InputStreamReader(new FileInputStream(file))); 
    5.   
  
  
  5.            // do some other work 
    6.   
  
  
  6.      } catch (FileNotFoundException e) { 
    7.   
  
  
  7.            e.printStackTrace(); 
    8.   
  
  
  8.      } finally { 
    9.   
  
  
  9.            try { 
    10.   
  
  
  10.                  reader.close(); 
    11.   
  
  
  11.            } catch (IOException e) { 
    12.   
  
  
  12.                  e.printStackTrace(); 
    13.   
  
  
  13.            } 
    14.   
  
  
  14.      } 
    15.   
  
  
  15. }  
    16.

例子非常的簡單，是一個讀取文件的例子。這樣的例子在JDBC操作中也非常的常見。(所以，我覺得對于資源的及時正確清理是一個程序員的基本素質(zhì)之一。)

Try…finally結(jié)構(gòu)也是保證資源正確關(guān)閉的一個手段。如果你不清楚代碼執(zhí)行過程中會發(fā)生什么異常情況會導(dǎo)致資源不能得到清理，那么你就用try對這段”可疑”代碼進(jìn)行包裝，然后在finally中進(jìn)行資源的清理。舉一個例子：

 
 
 
      
  
  
  1. public void readFile() { 
    2.   
  
  
  2.      BufferedReader reader = null; 
    3.   
  
  
  3.      try { 
    4.   
  
  
  4.            reader = new BufferedReader(new InputStreamReader(new FileInputStream("file"))); 
    5.   
  
  
  5.            // do some other work 
    6.   
  
  
  6.            //close reader 
    7.   
  
  
  7.            reader.close(); 
    8.   
  
  
  8.      } catch (FileNotFoundException e) { 
    9.   
  
  
  9.            e.printStackTrace(); 
    10.   
  
  
  10.      } catch (IOException e) { 
    11.   
  
  
  11.            e.printStackTrace(); 
    12.   
  
  
  12.      } 
    13.   
  
  
  13. }  
    14.

我們注意一下這個方法和上一個方法的區(qū)別，下一個人可能習(xí)慣更好一點，及早的關(guān)閉reader。但是往往事與愿違，因為在reader.close()以前異常隨時可能發(fā)生，這樣的代碼結(jié)構(gòu)不能預(yù)防任何異常的出現(xiàn)。因為程序會在異常出現(xiàn)的地方跳出，后面的代碼不能執(zhí)行(這在上面應(yīng)經(jīng)用實例證明過)。這時我們就可以用try…finally來改造：

 
 
 
      
  
  
  1. public void readFile() { 
    2.   
  
  
  2.      BufferedReader reader = null; 
    3.   
  
  
  3.      try { 
    4.   
  
  
  4.            try { 
    5.   
  
  
  5.                  reader = new BufferedReader(new InputStreamReader(new FileInputStream("file"))); 
    6.   
  
  
  6.                  // do some other work 
    7.   
  
  
  7.                  // close reader 
    8.   
  
  
  8.            } finally { 
    9.   
  
  
  9.                  reader.close(); 
    10.   
  
  
  10.            } 
    11.   
  
  
  11.       } catch (FileNotFoundException e) { 
    12.   
  
  
  12.            e.printStackTrace(); 
    13.   
  
  
  13.       } catch (IOException e) { 
    14.   
  
  
  14.            e.printStackTrace(); 
    15.   
  
  
  15.       } 
    16.   
  
  
  16. }  
    17.

及早的關(guān)閉資源是一種良好的行為，因為時間越長你忘記關(guān)閉的可能性越大。這樣在配合上try…finally就保證萬無一失了(不要嫌麻煩，java就是這么中規(guī)中矩)。

再說一種情況，假如我想在構(gòu)造方法中打開一個文件或者創(chuàng)建一個JDBC連接，因為我們要在其他的方法中使用這個資源，所以不能在構(gòu)造方法中及早的將這個資源關(guān)閉。那我們是不是就沒轍了呢?答案是否定的?？匆幌孪旅娴睦樱?/p>

 
 
 
      
  
  
  1. public class ResourceInConstructor { 
    2.   
  
  
  2.      BufferedReader reader = null; 
    3.   
  
  
  3.      public ResourceInConstructor() { 
    4.   
  
  
  4.           try { 
    5.   
  
  
  5.                 reader = new BufferedReader(new InputStreamReader(new FileInputStream(""))); 
    6.   
  
  
  6.           } catch (FileNotFoundException e) { 
    7.   
  
  
  7.                 e.printStackTrace(); 
    8.   
  
  
  8.           } 
    9.   
  
  
  9.      } 
    10.   
  
  
  10.      public void readFile() { 
    11.   
  
  
  11.           try { 
    12.   
  
  
  12.                  while(reader.readLine()!=null) { 
    13.   
  
  
  13.                       //do some work 
    14.   
  
  
  14.                  } 
    15.   
  
  
  15.           } catch (IOException e) { 
    16.   
  
  
  16.                  e.printStackTrace(); 
    17.   
  
  
  17.           } 
    18.   
  
  
  18.       } 
    19.   
  
  
  19.       public void dispose() { 
    20.   
  
  
  20.            try { 
    21.   
  
  
  21.                 reader.close(); 
    22.   
  
  
  22.            } catch (IOException e) { 
    23.   
  
  
  23.                 e.printStackTrace(); 
    24.   
  
  
  24.            } 
    25.   
  
  
  25.       } 
    26.   
  
  
  26. }  
    27.

這一部分講的多了一點，但是異常確實是看起來容易用起來難的東西呀，java中還是有好多的東西需要深挖的。


網(wǎng)頁名稱：深入探討Java中的異常與錯誤處理
鏈接URL：http://uogjgqi.cn/article/dpggoeo.html
掃二維碼與項目經(jīng)理溝通

我們在微信上24小時期待你的聲音

解答本文疑問/技術(shù)咨詢/運(yùn)營咨詢/技術(shù)建議/互聯(lián)網(wǎng)交流