2. 程式人生 > >Java——異常處理

Java——異常處理

阿新 • • 發佈：2017-10-07
上一個 分別是 類型轉換 冒號 意思 參數 ack span log

1、java提供的異常不可能預見所有的問題，所以需要自己定義異常類，必須從已有的異常類繼承，最好選擇意思相近的異常類繼承。

class MyException extends Exception{}

public class Tree1 {
    
    public static void f() throws MyException{
        System.out.println("throws MyException from f()");
        throw new MyException();
    }
        
    public static void
 
 main (String[] args) {
    
        try {
            f();
        }catch(MyException e){
            System.out.println("caught it");
        }
    }
}

try塊中的代碼將被監控，catch將會接受來自try塊的異常。這裏的f()方法將會拋出一個 MyException類的異常，然後catch將會接收到這個異常，並輸出caught it4

所以輸出結果為：

throws MyException from f()
caught it

可以為異常類定義一個接受字符串參數的構造器：

class MyException extends Exception{
    public MyException() {}
    public MyException(String msg) {
        super(msg);
    }
}
public class Tree1 {
    public static void f() throws MyException{
        System.out.println("throws MyException from f()");
        throw new MyException();
    }
        
    
 
public static void main (String[] args) {
        try {
            f();
        }catch(MyException e){
            e.printStackTrace(System.out);
        }
    }
}

這樣的輸出是：

throws MyException from f()
MyException
    at Tree1.f(Tree1.java:11)
    at Tree1.main(Tree1.java:16)

在異常類的定義中的第二個構造器中使用了super關鍵字明確調用了其基類構造器，它接受一個字符串作為參數。

在異常處理程序中，調用了Throwable類聲明的printStackTrace()方法，就像輸出中看到的這樣，它將會打印“從方法調用處直到異常拋出處” 的方法調用序列，這裏信息發送到了System.out，如果使用默認的e.printStackTrace();則信息將被輸出到標準錯誤流。

2、Exception類型的方法

class MyException extends Exception{
    public MyException() {}
    public MyException(String msg) {
        super(msg);
    }
}
class MySecondException extends Exception{
    public MySecondException() {}
    public MySecondException(String msg) {
        super(msg);
    }
}
public class Tree1 {
    public static void f() throws MyException {
        System.out.println("throws MyException from f()");
        throw new MyException("name");
    }
    
    public static void g() throws MySecondException {
        System.out.println("throws MySecondException from g()");
        throw new MySecondException("name2");
    }
        
    public static void main (String[] args){
        try {
            f();
//            g();
        }catch(Exception e){
            System.out.println(e.getMessage());
            System.out.println(e);
            System.out.println(e.getLocalizedMessage());
        }
    }
}

這裏定義了兩個繼承自Exception的異常類，分別是MyException、MySecondException，由兩個方法f()、g()拋出，如果在try塊中只有f();,輸出結果為：

throws MyException from f()
name
MyException: name
name

Throwable類的getMessage()方法返回的是Exception的詳細消息字符串，就是拋出這個異常時候傳入的字符串，

而getLocalizedMessage()方法返回的是 Exception的本地化描述。

toString()方法返回 此對象的類的 name ": "（冒號和一個空格）

然後如果把上面代碼g();的前面的//刪掉，就是try塊中將運行f()和g()兩個方法，輸出結果為：

throws MyException from f()
name
MyException: name
name

和剛才一樣這是因為catch接收到異常後就會結束try塊中的程序運行，所以g()方法並沒有被運行，所以如果先運行g()的結果就是：

throws MySecondException from g()
name2
MySecondException: name2
name2

3、棧軌跡

public class Tree1 {
    public static void f(){
        try {
            throw new Exception();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    
    public static void g() {f();}
    public static void h() {g();}
        
    public static void main (String[] args){
        f();        
        g();
        h();
    }
}

輸出結果為：

java.lang.Exception
    at Tree1.f(Tree1.java:17)
    at Tree1.main(Tree1.java:27)
java.lang.Exception
    at Tree1.f(Tree1.java:17)
    at Tree1.g(Tree1.java:23)
    at Tree1.main(Tree1.java:28)
java.lang.Exception
    at Tree1.f(Tree1.java:17)
    at Tree1.g(Tree1.java:23)
    at Tree1.h(Tree1.java:24)
    at Tree1.main(Tree1.java:29)

這裏的調用的printStackTrace()，是Throwable類的方法，這個方法會將Throwable對象的棧軌跡信息打印到標準錯誤輸出流上，第一行是異常類的tostring()方法輸出的內容，後面幾行的內容都是之前通過fillInStackTrace()方法保存的內容。

java.lang.Exception
    at Tree1.f(Tree1.java:17)
    at Tree1.main(Tree1.java:27)

在這個例子中，在方法f()中拋出異常，在main方法中捕獲異常，並且打印棧軌跡信息。因此，輸出依次展示了f—>main的過程。還打印了拋出錯誤，捕獲錯誤的行數、類的名字。

java.lang.Exception
    at Tree1.f(Tree1.java:17)
    at Tree1.g(Tree1.java:23)
    at Tree1.main(Tree1.java:28)

這裏就是在方法f()中拋出異常，方法g()中調用了f()，然後和上一個一樣了，第三個也同樣。

public class Tree1 {
    public static void f(){
        try {
            throw new Exception();
        }catch(Exception e){
            for(StackTraceElement ste: e.getStackTrace()) {            
                System.out.println(ste);

            }
        }
    }
    
    public static void g() {f();}
    public static void h() {g();}
        
    public static void main (String[] args){
        f();
        System.out.println("------------------");
        g();
        System.out.println("------------------");
        h();
    }
}

這個例子中調用了getStackTrace()方法，這個方法返回StackTraceElement類的一個對象。其輸出內容為：

Tree1.f(Tree1.java:17)
Tree1.main(Tree1.java:30)
------------------
Tree1.f(Tree1.java:17)
Tree1.g(Tree1.java:26)
Tree1.main(Tree1.java:32)
------------------
Tree1.f(Tree1.java:17)
Tree1.g(Tree1.java:26)
Tree1.h(Tree1.java:27)
Tree1.main(Tree1.java:34)

如果這樣使用：

public class Tree1 {
    public static void f(){
        try {
            throw new Exception();
        }catch(Exception e){
            for(StackTraceElement ste: e.getStackTrace()) {            
                System.out.print(ste.getMethodName() + "  " );
                System.out.println(ste.getLineNumber());
            }
        }
    }
    
    public static void g() {f();}
    public static void h() {g();}
        
    public static void main (String[] args){
        f();
        System.out.println("------------------");
        g();
        System.out.println("------------------");
        h();
    }
}

調用StackTraceElement中的方法getMethodName()和getLineNumber()就可以值獲取棧軌跡中的方法 和行：

f  17
main  30
------------------
f  17
g  26
main  32
------------------
f  17
g  26
h  27
main  34

所以，其實StackTraceElement是一個棧軌跡元素的數組。將這些棧軌跡元素保存在一個數組中。每個元素對應棧的一個棧幀。數組的第一個元素保存的是棧頂元素，也就是上面的f。最後一個元素保存的棧底元素,也就是main。

public class Tree1 {
    public static void f() throws Exception{
            throw new Exception();
    }
    
    public static void g() throws Exception {
            try {
                f();
            }catch(Exception e){
                e.printStackTrace();
                throw e;
                }
    }
        
    public static void main (String[] args){
        try {
            g();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

4、重新拋出異常

這裏f()函數中拋出一個異常，然後g()方法中捕獲了這個異常並打印異常棧軌跡Stack Trace，然後又再拋出了剛剛的異常，mai方法中捕獲 了這個異常並打印異常棧軌跡Stack Trace，所以結果為：

java.lang.Exception
    at Tree1.f(Tree1.java:16)
    at Tree1.g(Tree1.java:21)
    at Tree1.main(Tree1.java:30)
java.lang.Exception
    at Tree1.f(Tree1.java:16)
    at Tree1.g(Tree1.java:21)
    at Tree1.main(Tree1.java:30)

也就是說，捕獲到異常又立即拋出，在上級方法調用中再次捕獲這個異常，打印的棧軌跡信息是一樣的。額，其實只看代碼也知道，因為這裏只是把剛剛異常e又拋出一次，

public class Tree1 {
    public static void f() throws Exception{
            throw new Exception();
    }
    
    public static void g() throws Exception {
            try {
                f();
            }catch(Exception e){
                e.printStackTrace();
                throw (Exception)e.fillInStackTrace();
                }
    }
        
    public static void main (String[] args){
        try {
            g();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

throw (Exception)e.fillInStackTrace();

這一行調用了Exception的fillInStackTrace()方法，首先要知道其實這個方法並不是來自於Exception類。Exception類本身除了定義了幾個構造器之外，所有的方法都是從其父類繼承過來的。而和異常相關的方法都是從java.lang.Throwable類繼承過來的，所以其實fillInStackTrace()是Throwable類的方法，然後fillInStackTrace()方法就是將當前線程當前狀態下的軌跡棧的狀態保存進Throwabe中，就是更新的意思。

public Throwable fillInStackTrace()

這是這個方法的原型所以它的返回值是一個Throwable類對象，所以使用它更新的時候需要強制類型轉換。

throw (Exception)e.fillInStackTrace();

所以輸出內容為：

java.lang.Exception
    at Tree1.f(Tree1.java:16)
    at Tree1.g(Tree1.java:21)
    at Tree1.main(Tree1.java:30)
java.lang.Exception
    at Tree1.g(Tree1.java:24)
    at Tree1.main(Tree1.java:30)

這次第二個打印的棧軌跡信息就沒有f了。

5、異常鏈

class MyException1 extends Exception{} 


class MyException2 extends Exception{}

public class Tree1 {
    
    public static void f() throws MyException1{
        throw new MyException1();
    }
    
    public static void g() throws MyException2{
        try {
            f();
        } catch (MyException1 e) {
            e.printStackTrace();
            throw new MyException2();
        }
    }

        
    public static void main (String[] args){
        try {
            g();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

這裏定義了兩個異常類，f()方法拋出了MyException1，g()方法捕獲了這個異常並打印了異常的棧軌鏈，然後拋出了另一個異常MyException2也打印了異常的棧軌鏈，所以輸出結果為：

MyException1
    at Tree1.f(Tree1.java:16)
    at Tree1.g(Tree1.java:21)
    at Tree1.main(Tree1.java:31)
MyException2
    at Tree1.g(Tree1.java:24)
    at Tree1.main(Tree1.java:31)

這沒什麽毛病，但是常常想要在捕獲一個異常後拋出另一個異常，並且希望把原始異常的信息保存下來，這就需要將原始異常的信息包裝在新的異常中，這被稱為異常鏈

class MyException1 extends Exception{} 


class MyException2 extends Exception{
    MyException2(Throwable throwable){
        super(throwable);
    }
    MyException2(){
        super();
    }
}
public class Tree1 {
    
    public static void f() throws MyException1{
        throw new MyException1();
    }
    
    public static void g() throws MyException2{
        try {
            f();
        } catch (MyException1 e) {
            e.printStackTrace();
            throw new MyException2(e);
        }
    }

        
    public static void main (String[] args){
        try {
            g();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

這樣的輸出結果就是：

MyException1
    at Tree1.f(Tree1.java:16)
    at Tree1.g(Tree1.java:21)
    at Tree1.main(Tree1.java:31)
MyException2: MyException1
    at Tree1.g(Tree1.java:24)
    at Tree1.main(Tree1.java:31)
Caused by: MyException1
    at Tree1.f(Tree1.java:16)
    at Tree1.g(Tree1.java:21)
    ... 1 more

這樣的定義：

public class MyException2 extends Exception{  
    //定義異常的原因  
    public MyException2(String message){  
        super(message);  
    }  
  
    //定義異常原因，並攜帶原始的異常  
    public MyException2(String message,Throwable cause){  
        super(message,cause);  
    }  
  
    //保留原始異常信息  
    publicMyException2(Throwable cause){  
        super(cause);  
    }  
}

就能將原始異常傳遞給新異常

或是：

class MyException1 extends Exception{
} 


class MyException2 extends Exception{
    MyException2(Throwable throwable){
        super(throwable);
    }
    MyException2(){
        super();
    }
}

class MyException3 extends Exception{
    MyException3(Throwable throwable){
        super(throwable);
    }
    MyException3(){
        super();
    }
}

public class Tree1 {
    
    public static void f() throws MyException1{
        throw new MyException1();
    }
    
    public static void g() throws MyException2{
        try {
            f();
        } catch (MyException1 e) {
//            e.printStackTrace();
            throw new MyException2(e);
        }
    }
    
    public static void h() throws MyException3{
        try {
            g();
        } catch (MyException2 e) {
//            e.printStackTrace();
            throw new MyException3(e);
        }
    }

        
    public static void main (String[] args){
        try {
            h();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

這裏值輸出了最後一個異常的棧軌跡

MyException3: MyException2: MyException1
    at Tree1.h(Tree1.java:44)
    at Tree1.main(Tree1.java:51)
Caused by: MyException2: MyException1
    at Tree1.g(Tree1.java:35)
    at Tree1.h(Tree1.java:41)
    ... 1 more
Caused by: MyException1
    at Tree1.f(Tree1.java:27)
    at Tree1.g(Tree1.java:32)
    ... 2 more

其中還包括了MyException1和MyException2 的信息

Exception

Java——異常處理

相關推薦

Java 異常處理和 Log4j 配置文件

images orm 信息 not bound img source jar 下標 一、 程序錯誤 警告：黃線：Warning 錯誤：資源類：系統級（線程）/ 環境級（繪圖） 異常：編譯級：Exception 運行級：Exception -> RuntimeExc

15. Java異常處理

ace hover 避免 構造函數 裏的 width 原因 sans 克隆對象 html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,addre

java異常處理

並不是 9.png 代碼塊 可能 函數 處理異常 finall int 將不 一 異常： 是指程序運行的過程中，發生某些意外的事情，比如10除以0， 文件不存在等。 例如： pub

項目中java異常處理

tails 驗證 包含 erro csdn 拋出異常 項目 cep ble 一、java異常類介紹。 Throwable： 有兩個重要的子類：Exception（異常）和 Error（錯誤），二者都是 Java 異常處理的重要子類，各自都包含大量子類。 有一篇比較好的b

Java 異常處理

nal fbo 失敗 類定義 參數 方法 ray 接下來 語法檢查 閱讀目錄 異常的概念 異常的體系結構 Java 異常的處理機制 異常處理的基本語法 異常鏈 自定義異常 總結 回到頂部 異常的概念 異常是程序中的一些錯誤，但並不是所有的錯誤都是異常，並且錯誤有時候

實習培訓——Java異常處理（8）

如何工作 出了 我們 個數 試圖 類對象 bject epo 很多 實習培訓——Java異常處理（8） Java 異常處理 異常是程序中的一些錯誤，但並不是所有的錯誤都是異常，並且錯誤有時候是可以避免的。 比如說，你的代碼少了一個分號，那麽運行出來結果是提示是錯誤 java

Java——異常處理

上一個 分別是 類型轉換 冒號 意思 參數 ack span log 1、java提供的異常不可能預見所有的問題，所以需要自己定義異常類，必須從已有的異常類繼承，最好選擇意思相近的異常類繼承。 class MyException extends Exception{}

Java - 異常處理

一個 普通 throw oid 基類 語句 內容 推薦 出現 主要內容： * Java 異常的概念。 * Java 異常的分類。 * 異常的捕獲和處理。 Q：Java 是如何對異常進行處理的？ A：Java 中定義了很多異常類，這些類對應了各種各樣可能出現的異常事

java異常處理的機制 java 架構師學習 java北京

語句 變量 point try ray 多重 span throw 創建 在Java中，異常情況分為Exception（異常）和Error（錯誤）兩大類，Java異常通常是指程序運行過程中出現的非正常情況，如用戶輸入錯誤、除數為零、需要處理的文件不存在、數組下標越界等，對於

【Java入門提高篇】Day16 Java異常處理（下）

http final 自定義異常 2個 輸入 也有 推薦 錯誤 num 　　今天繼續講解java中的異常處理機制，主要介紹Exception家族的主要成員，自定義異常，以及異常處理的正確姿勢。 Exception家族 　　一圖勝千言，先來看一張圖。 　　Excepti

Java 異常處理的誤區和經驗總結

ORC 進一步 相關 ror final 額外 檢測 業務 清理資源 一 異常分檢測異常和非檢測異常，異常的應用情景可以概括為以下： 調用代碼不能繼續執行，需要立即終止。出現這種情況的可能性太多太多，例如服務器連接不上、參數不正確等。這些時候都適用非檢測異常，不需要調用

程序設計中關於Java 異常處理應註意的問題

異常處理 try...catch Java 異常處理初識 下面程序，雖能運行，但當數據輸入有誤時程序不能正常結束，也就是說，程序本身沒有進行異常處理。 例題001 用Java編寫程序。輸入兩個整數，輸出它們的商。 import java.util.Scanner;public class MyAd

深入理解Java異常處理機制 （籠統篇）

throw 種類型 綜合 IV 算術 其它 wid all 作用 開篇 1.異常處理(Exception Handling)： 　　就是一種解決這一問題的機制，能夠較好地處理程序不能正常運行的情況。 2.異常(Exception)： 　　是程序在運行時可能出現的

每日一題：Java異常處理

增加 異常處理 int throwable 邏輯 現實 inter throws 運行時 什麽是異常 在理想情況下，程序總會運行在很完美的環境中，網絡不會終端，文件一定存在，程序不會有 BUG。但是，理想很豐滿，現實很骨幹，實際生產環境中，網絡可能會中斷，文件可能會找不到，

Java異常處理總結

tst error 有一個 ror 而是 阻止 cep 行處理 編碼 一、Java 異常繼承框架 Error： Error類對象由 Java 虛擬機生成並拋出，大多數錯誤與代碼編寫者所執行的操作無關。對於設計合理的應用程序來說，即使確實發生了錯誤，本質上也不應該試圖去處理

java異常處理中的return和throw

如果把return和throw放在一起，直接會提示錯誤。"Unreachable statement"（無法被執行）. 然而finally卻可以成功騙過編譯器讓兩者並存（是不是可以算是編譯器的一個小bug呢），結果是後執行的會覆蓋前者。 finally如果有return會覆蓋cat

java 異常處理之宣告丟擲異常

java 異常處理宣告丟擲異常 2.宣告丟擲異常是Java中處理異常的第二種方式 2.宣告丟擲異常是Java中處理異常的第二種方式 如果一個方法(中的語句執行時)可能生成某種異常，但是並不能確定如何處理這種異常，則此方

java 異常處理機制，throws與throw，try-catch-finally

java 異常處理機制 1.Java異常處理 2.try-catch-finally的程式流程圖 3.關鍵解讀 4.demo 5.不捕獲異常時的情況 在編寫程式時，經常要在可能出現錯誤的地方

java 異常處理方式之一 try—catch——finally

java 異常處理方式之一: try—catch——finally 1. 如何處理Exception的異常 2. 注： 3.dome 1. 如何處理Exception的異常 Java提供的是異常處理的抓拋模型為

java基礎學習總結（十三）：Java異常處理

一、JAVA異常       異常是指不期而至的各種情況，如：檔案找不到、網路連線失敗、非法引數等。異常是一個事件，它發生在程式執行期間，干擾了正常的指令流程。Java通過API中的Throwable類的眾多子類描述各種不同的異常。因而，Java異常都是物件，是Th