公与淑婷厨房猛烈进出视频免费,97久久精品无码一区二区天美

首頁

Java

Java基礎(chǔ)

JAVA異常與異常處理詳解

尚

Nov 27, 2019 pm 05:39 PM

java

JAVA異常與異常處理詳解

一、異常簡介

什麼是異常？

異常就是有異於常態(tài)，和正常情況不一樣，有錯誤出錯。在java中，阻止目前方法或作用域的情況，稱之為異常。

java中異常的體係是怎麼樣的呢？（建議：java影片教學(xué)）

1.Java中的所有不正常類別都繼承於Throwable類別。 Throwable主要包括兩個大類，一個是Error類，另一個是Exception類；

JAVA異常與異常處理詳解

#2.其中Error類中包括虛擬機(jī)錯誤和線程死鎖，一旦Error出現(xiàn)了，程式就徹底的掛了，被稱為程式終結(jié)者；

JAVA異常與異常處理詳解

#3.Exception類，也就是通常所說的「異?！?。主要指編碼、環(huán)境、使用者操作輸入出現(xiàn)問題，Exception主要包括兩大類，非檢查異常（RuntimeException）和檢查異常（其他的一些異常）

JAVA異常與異常處理詳解

4 .RuntimeException異常主要包括以下四種異常（其實(shí)還有很多其他異常，這裡不一一列出）：空指標(biāo)異常、陣列下標(biāo)越界異常、型別轉(zhuǎn)換異常、算術(shù)異常。 RuntimeException異常會由java虛擬機(jī)器自動拋出並自動捕獲（就算我們沒寫異常捕獲語句運(yùn)行時也會拋出錯誤?。。?，此類異常的出現(xiàn)絕大數(shù)情況是代碼本身有問題應(yīng)該從邏輯上去解決並改進(jìn)程式碼。

JAVA異常與異常處理詳解 5.檢查異常，造成該異常的原因多種多樣，例如檔案不存在、或是連線錯誤等等。跟它的「兄弟」RuntimeException運(yùn)行異常不同，該異常我們必須手動在程式碼裡添加捕獲語句來處理該異常，這也是我們學(xué)習(xí)java異常語句中主要處理的異常對象。

JAVA異常與異常處理詳解

二、try-catch-finally語句

（1）try區(qū)塊：負(fù)責(zé)捕獲異常，一旦try中發(fā)現(xiàn)異常，程式的控制權(quán)將移交給catch區(qū)塊中的異常處理程序。

【try語句區(qū)塊不可以獨(dú)立存在，必須與 catch 或 finally 區(qū)塊同存】

（2）catch區(qū)塊：如何處理？例如發(fā)出警告：提示、檢查配置、網(wǎng)路連接，記錄錯誤等。執(zhí)行完catch區(qū)塊之後程式跳出catch區(qū)塊，繼續(xù)執(zhí)行後面的程式碼。

【編寫catch塊的注意事項(xiàng)：多個catch塊處理的異常類，要按照先catch子類後catch父類的處理方式，因?yàn)闀揪徒幚怼慨惓＃ㄓ缮献韵拢?。】

（3）finally：最終執(zhí)行的程式碼，用於關(guān)閉和釋放資源。

語法格式如下：

try{
//一些會拋出的異常
}catch（Exception e）{
//第一個catch
//處理該異常的代碼塊
}catch（Exception e）{
//第二個catch，可以有多個catch
//處理該異常的代碼塊
}finally{
//最終要執(zhí)行的代碼
}

當(dāng)異常出現(xiàn)時，程式將終止執(zhí)行，交由異常處理程序（拋出提醒或記錄日誌等），異常代碼區(qū)塊外程式碼正常執(zhí)行。 try會拋出很多種類型的異常，由多個catch區(qū)塊捕捉多鐘錯誤。

多重異常處理程式碼區(qū)塊順序問題：先子類別再父類別（順序不對編譯器會提醒錯誤），finally語句區(qū)塊處理最終將要執(zhí)行的程式碼。

接下來，我們用實(shí)例來鞏固try-catch語句吧~

先看範(fàn)例：

package com.hysum.test;

public class TryCatchTest {
    /**
     * divider:除數(shù)
     * result:結(jié)果
     * try-catch捕獲while循環(huán)
     * 每次循環(huán)，divider減一，result=result+100/divider
     * 如果：捕獲異常，打印輸出“異常拋出了”，返回-1
     * 否則：返回result
     * @return
     */
    public int test1(){
        int divider=10;
        int result=100;
        try{
            while(divider>-1){
                divider--;
                result=result+100/divider;
            }
            return result;
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("異常拋出了！！");
            return -1;
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TryCatchTest t1=new TryCatchTest();
        System.out.println("test1方法執(zhí)行完畢！result的值為："+t1.test1());
    }
    
}

執(zhí)行結(jié)果：

JAVA異常與異常處理詳解

結(jié)果分析：結(jié)果中的紅色字拋出的異常訊息是由e.printStackTrace()來輸出的，它說明了這裡我們拋出的異常類型是算數(shù)異常，後面還跟著原因：by zero （由0造成的算數(shù)異常），下面兩行at顯示了造成此異常的程式碼具體位置。

在上面範(fàn)例中再加上一個test2()方法來測試finally語句的執(zhí)行狀況：

/**
     * divider:除數(shù)
     * result:結(jié)果
     * try-catch捕獲while循環(huán)
     * 每次循環(huán)，divider減一，result=result+100/divider
     * 如果：捕獲異常，打印輸出“異常拋出了”，返回result=999
     * 否則：返回result
     * finally：打印輸出“這是finally，哈哈哈！！”同時打印輸出result
     * @return
     */
    public int test2(){
        int divider=10;
        int result=100;
        try{
            while(divider>-1){
                divider--;
                result=result+100/divider;
            }
            return result;
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("異常拋出了??！");
            return result=999;
        }finally{
            System.out.println("這是finally，哈哈哈?。?quot;);
            System.out.println("result的值為："+result);
        }        
    }         
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TryCatchTest t1=new TryCatchTest();
        //System.out.println("test1方法執(zhí)行完畢！result的值為："+t1.test1());
        t1.test2();
        System.out.println("test2方法執(zhí)行完畢！");
    }

運(yùn)行結(jié)果：

JAVA異常與異常處理詳解

# #結(jié)果分析：我們可以從結(jié)果看出，finally語句區(qū)塊是在try區(qū)塊和catch區(qū)塊語句執(zhí)行之後最後執(zhí)行的。 finally是在return後面的表達(dá)式運(yùn)算後執(zhí)行的（此時並沒有回傳運(yùn)算後的值，而是先把要回傳的值保存起來，管finally中的程式碼怎麼樣，傳回的值都不會改變，仍然是之前儲存的值），所以函數(shù)傳回值是在finally執(zhí)行前確定的；

這里有個有趣的問題，如果把上述中的test2方法中的finally語句塊中加上return，編譯器就會提示警告：finally block does not complete normally

public int test2(){
        int divider=10;
        int result=100;
        try{
            while(divider>-1){
                divider--;
                result=result+100/divider;
            }
            return result;
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("異常拋出了?。?quot;);
            return result=999;
        }finally{
            System.out.println("這是finally，哈哈哈?。?quot;);
            System.out.println("result的值為："+result);
            return result;//編譯器警告
        }
        
    }

JAVA異常與異常處理詳解

分析問題: finally塊中的return語句可能會覆蓋try塊、catch塊中的return語句;如果finally塊中包含了return語句，即使前面的catch塊重新拋出了異常，則調(diào)用該方法的語句也不會獲得catch塊重新拋出的異常，而是會得到finally塊的返回值，并且不會捕獲異常。

解決問題：面對上述情況，其實(shí)更合理的做法是，既不在try block內(nèi)部中使用return語句，也不在finally內(nèi)部使用 return語句，而應(yīng)該在 finally 語句之后使用return來表示函數(shù)的結(jié)束和返回。如：

JAVA異常與異常處理詳解

總結(jié)：

1、不管有木有出現(xiàn)異常或者try和catch中有返回值return，finally塊中代碼都會執(zhí)行；

2、finally中最好不要包含return，否則程序會提前退出，返回會覆蓋try或catch中保存的返回值。

3、 e.printStackTrace()可以輸出異常信息。

4、 return值為-1為拋出異常的習(xí)慣寫法。

5、如果方法中try,catch,finally中沒有返回語句，則會調(diào)用這三個語句塊之外的return結(jié)果。

6、 finally 在try中的return之后在返回主調(diào)函數(shù)之前執(zhí)行。

三、throw和throws關(guān)鍵字

java中的異常拋出通常使用throw和throws關(guān)鍵字來實(shí)現(xiàn)。

throw ----將產(chǎn)生的異常拋出，是拋出異常的一個動作。

一般會用于程序出現(xiàn)某種邏輯時程序員主動拋出某種特定類型的異常。如：

語法：throw (異常對象)，如：

public static void main(String[] args) { 
    String s = "abc"; 
    if(s.equals("abc")) { 
      throw new NumberFormatException(); 
    } else { 
      System.out.println(s); 
    } 
    //function(); 
}

運(yùn)行結(jié)果：

Exception in thread "main" java.lang.NumberFormatException
at test.ExceptionTest.main(ExceptionTest.java:67)

throws----聲明將要拋出何種類型的異常（聲明）。

語法格式：

 public void 方法名（參數(shù)列表）
    throws 異常列表{
 //調(diào)用會拋出異常的方法或者：
 throw new Exception（）；
 }

當(dāng)某個方法可能會拋出某種異常時用于throws 聲明可能拋出的異常，然后交給上層調(diào)用它的方法程序處理。如：

public static void function() throws NumberFormatException{ 
    String s = "abc"; 
    System.out.println(Double.parseDouble(s)); 
  } 
    
  public static void main(String[] args) { 
    try { 
      function(); 
    } catch (NumberFormatException e) { 
      System.err.println("非數(shù)據(jù)類型不能轉(zhuǎn)換。"); 
      //e.printStackTrace(); 
    } 
}

throw與throws的比較

1、throws出現(xiàn)在方法函數(shù)頭；而throw出現(xiàn)在函數(shù)體。

2、throws表示出現(xiàn)異常的一種可能性，并不一定會發(fā)生這些異常；throw則是拋出了異常，執(zhí)行throw則一定拋出了某種異常對象。

3、兩者都是消極處理異常的方式（這里的消極并不是說這種方式不好），只是拋出或者可能拋出異常，但是不會由函數(shù)去處理異常，真正的處理異常由函數(shù)的上層調(diào)用處理。

來看個例子：

throws e1,e2,e3只是告訴程序這個方法可能會拋出這些異常，方法的調(diào)用者可能要處理這些異常，而這些異常e1，e2，e3可能是該函數(shù)體產(chǎn)生的。

throw則是明確了這個地方要拋出這個異常。如：

void doA(int a) throws (Exception1,Exception2,Exception3){
      try{
         ......
 
      }catch(Exception1 e){
       throw e;
      }catch(Exception2 e){
       System.out.println("出錯了！");
      }
      if(a!=b)
       throw new Exception3("自定義異常");
}

分析:

1、代碼塊中可能會產(chǎn)生3個異常，(Exception1,Exception2,Exception3)。

2、如果產(chǎn)生Exception1異常，則捕獲之后再拋出，由該方法的調(diào)用者去處理。

3、如果產(chǎn)生Exception2異常，則該方法自己處理了（即System.out.println("出錯了！");）。所以該方法就不會再向外拋出Exception2異常了，void doA() throws Exception1,Exception3 里面的Exception2也就不用寫了。因?yàn)橐呀?jīng)用try-catch語句捕獲并處理了。

4、Exception3異常是該方法的某段邏輯出錯，程序員自己做了處理，在該段邏輯錯誤的情況下拋出異常Exception3，則該方法的調(diào)用者也要處理此異常。這里用到了自定義異常，該異常下面會由解釋。

使用throw和throws關(guān)鍵字需要注意以下幾點(diǎn)：

1.throws的異常列表可以是拋出一條異常，也可以是拋出多條異常，每個類型的異常中間用逗號隔開

2.方法體中調(diào)用會拋出異常的方法或者是先拋出一個異常：用throw new Exception（） throw寫在方法體里，表示“拋出異常”這個動作。

3.如果某個方法調(diào)用了拋出異常的方法，那么必須添加try catch語句去嘗試捕獲這種異常，或者添加聲明，將異常拋出給更上一層的調(diào)用者進(jìn)行處理

自定義異常

為什么要使用自定義異常，有什么好處？

1、我們在工作的時候，項(xiàng)目是分模塊或者分功能開發(fā)的 ,基本不會你一個人開發(fā)一整個項(xiàng)目，使用自定義異常類就統(tǒng)一了對外異常展示的方式。

2、有時候我們遇到某些校驗(yàn)或者問題時，需要直接結(jié)束掉當(dāng)前的請求，這時便可以通過拋出自定義異常來結(jié)束，如果你項(xiàng)目中使用了SpringMVC比較新的版本的話有控制器增強(qiáng)，可以通過@ControllerAdvice注解寫一個控制器增強(qiáng)類來攔截自定義的異常并響應(yīng)給前端相應(yīng)的信息。

3、自定義異?？梢栽谖覀冺?xiàng)目中某些特殊的業(yè)務(wù)邏輯時拋出異常，比如"中性".equals(sex)，性別等于中性時我們要拋出異常，而Java是不會有這種異常的。系統(tǒng)中有些錯誤是符合Java語法的，但不符合我們項(xiàng)目的業(yè)務(wù)邏輯。

4、使用自定義異常繼承相關(guān)的異常來拋出處理后的異常信息可以隱藏底層的異常，這樣更安全，異常信息也更加的直觀。自定義異常可以拋出我們自己想要拋出的信息，可以通過拋出的信息區(qū)分異常發(fā)生的位置，根據(jù)異常名我們就可以知道哪里有異常，根據(jù)異常提示信息進(jìn)行程序修改。比如空指針異常NullPointException，我們可以拋出信息為“xxx為空”定位異常位置，而不用輸出堆棧信息。

說完了為什么要使用自定義異常，有什么好處，我們再來看看自定義異常的毛?。?/p>

我們不可能期待JVM（Java虛擬機(jī)）自動拋出一個自定義異常，也不能夠期待JVM會自動處理一個自定義異常。發(fā)現(xiàn)異常、拋出異常以及處理異常的工作必須靠編程人員在代碼中利用異常處理機(jī)制自己完成。這樣就相應(yīng)的增加了一些開發(fā)成本和工作量，所以項(xiàng)目沒必要的話，也不一定非得要用上自定義異常，要能夠自己去權(quán)衡。

最后，我們來看看怎么使用自定義異常：

在 Java 中你可以自定義異常。編寫自己的異常類時需要記住下面的幾點(diǎn)。

所有異常都必須是 Throwable 的子類。

如果希望寫一個檢查性異常類，則需要繼承 Exception 類。

如果你想寫一個運(yùn)行時異常類，那么需要繼承 RuntimeException 類。

可以像下面這樣定義自己的異常類：

class MyException extends Exception{ }

我們來看一個實(shí)例：

package com.hysum.test;
public class MyException extends Exception {
     /**
     * 錯誤編碼
     */
    private String errorCode;   
    public MyException(){}
    
    /**
     * 構(gòu)造一個基本異常.
     *
     * @param message
     *        信息描述
     */
    public MyException(String message)
    {
        super(message);
    }
    public String getErrorCode() {
        return errorCode;
    }
    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }   
}

使用自定義異常拋出異常信息：

package com.hysum.test;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] sexs = {"男性","女性","中性"};
                  for(int i = 0; i < sexs.length; i++){
                      if("中性".equals(sexs[i])){
                          try {
                            throw new MyException("不存在中性的人！");
                        } catch (MyException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                     }else{
                         System.out.println(sexs[i]);
                     }
                } 
    }

}

運(yùn)行結(jié)果：

JAVA異常與異常處理詳解

四、java中的異常鏈

異常需要封裝，但是僅僅封裝還是不夠的，還需要傳遞異常。

異常鏈?zhǔn)且环N面向?qū)ο缶幊碳夹g(shù)，指將捕獲的異常包裝進(jìn)一個新的異常中并重新拋出的異常處理方式。原異常被保存為新異常的一個屬性（比如cause）。這樣做的意義是一個方法應(yīng)該拋出定義在相同的抽象層次上的異常，但不會丟棄更低層次的信息。

我可以這樣理解異常鏈：

把捕獲的異常包裝成新的異常，在新異常里添加原始的異常，并將新異常拋出，它們就像是鏈?zhǔn)椒磻?yīng)一樣，一個導(dǎo)致（cause）另一個。這樣在最后的頂層拋出的異常信息就包括了最底層的異常信息。

》場景

比如我們的JEE項(xiàng)目一般都又三層：持久層、邏輯層、展現(xiàn)層，持久層負(fù)責(zé)與數(shù)據(jù)庫交互，邏輯層負(fù)責(zé)業(yè)務(wù)邏輯的實(shí)現(xiàn)，展現(xiàn)層負(fù)責(zé)UI數(shù)據(jù)的處理。

有這樣一個模塊：用戶第一次訪問的時候，需要持久層從user.xml中讀取數(shù)據(jù)，如果該文件不存在則提示用戶創(chuàng)建之。

那問題就來了：如果我們直接把持久層的異常FileNotFoundException拋棄掉，邏輯層根本無從得知發(fā)生任何事情，也就不能為展現(xiàn)層提供一個友好的處理結(jié)果，最終倒霉的就是展現(xiàn)層：沒有辦法提供異常信息，只能告訴用戶“出錯了，我也不知道出了什么錯了”—毫無友好性而言。

正確的做法是先封裝，然后傳遞，過程如下：

1、把FileNotFoundException封裝為MyException。

2、拋出到邏輯層，邏輯層根據(jù)異常代碼（或者自定義的異常類型）確定后續(xù)處理邏輯，然后拋出到展現(xiàn)層。

3、展現(xiàn)層自行確定展現(xiàn)什么，如果管理員則可以展現(xiàn)低層級的異常，如果是普通用戶則展示封裝后的異常。

示例

package com.hysum.test;

public class Main {
    public void test1() throws RuntimeException{
        String[] sexs = {"男性","女性","中性"};
        for(int i = 0; i < sexs.length; i++){
            if("中性".equals(sexs[i])){
                try {
                    throw new MyException("不存在中性的人！");
                } catch (MyException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    RuntimeException rte=new RuntimeException(e);//包裝成RuntimeException異常
                    //rte.initCause(e);
                    throw rte;//拋出包裝后的新的異常
                }
           }else{
               System.out.println(sexs[i]);
           }
      } 
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Main m =new Main();
        
        try{
        m.test1();
        }catch (Exception e){
            e.printStackTrace();
            e.getCause();//獲得原始異常
        }
        
    }

}

運(yùn)行結(jié)果：

1JAVA異常與異常處理詳解