異常的基本概念：

異常指程序在執(zhí)行過程中出現(xiàn)，程序本身沒有預(yù)料的情況，例如讀取文件，操作時(shí)文件不存在訪問數(shù)據(jù)庫(kù)，是驅(qū)動(dòng)程序，不存在進(jìn)行算數(shù)，除法運(yùn)算時(shí)除數(shù)為零等情情況。

這些情況的出現(xiàn)，可能會(huì)導(dǎo)致程序出現(xiàn)不正確的邏輯或者導(dǎo)致程序結(jié)束異常，是不可避免的，出現(xiàn)了什么樣的異常，由誰(shuí)來處理異常，如何處理異常？

傳統(tǒng)面向過程的程序語(yǔ)言，例如C語(yǔ)言，通常根據(jù)程序返回的某個(gè)特殊值或標(biāo)記，并且假定接受者會(huì)檢查該返回值或標(biāo)記，以此來判斷異常是否發(fā)生這種處理方式，會(huì)在程序的許多地方逐一查某個(gè)特定的異常并加以處理，導(dǎo)致正常的業(yè)務(wù)流程和異常處理代碼緊密耦合，不利于代碼的閱讀和維護(hù)。

相比于其他語(yǔ)言來講，java提供的異常處理機(jī)制具有以下優(yōu)點(diǎn)：

1：將描述業(yè)務(wù)邏輯的代碼與處理異常的代碼分離，從而使代碼的可讀性撰寫，調(diào)試和維護(hù)都大大提高。

2：把錯(cuò)誤傳播給調(diào)用堆棧

3：按錯(cuò)誤類型和錯(cuò)誤差別分組

3：系統(tǒng)提供了對(duì)于一些無法預(yù)料的錯(cuò)誤的捕獲和處理

4：克服了傳統(tǒng)方法的錯(cuò)誤信息有限的問題

使用異常處理的目的就是用來在發(fā)生異常時(shí)高數(shù)程序如何控制自身的運(yùn)行，防止錯(cuò)誤進(jìn)一步惡化，從而導(dǎo)致嚴(yán)重的后果

Java異常的體系結(jié)構(gòu)：

Throwable是所有異常和錯(cuò)誤的父類，它主要包含了三個(gè)方面的內(nèi)容：

1:線程創(chuàng)建時(shí)執(zhí)行堆棧的快照。

2：用于描述異?；蝈e(cuò)誤出現(xiàn)位置的消息字符串。

3：異?；蝈e(cuò)誤產(chǎn)生的原因

Throwable有兩個(gè)直接子類：Error和Exception，分別表示錯(cuò)誤和異常，其中異常Exception又包括兩大類：運(yùn)行時(shí)異常(RuntimeException)和非運(yùn)行時(shí)異常。

運(yùn)行時(shí)異常又稱為編譯器不檢查的異常(Unchecked Exception),非運(yùn)行時(shí)異常又稱為編譯器檢查的異常(checked Exception)

Error與Exception:

Error類層次結(jié)構(gòu)描述了Java運(yùn)行時(shí)系統(tǒng)的內(nèi)部錯(cuò)誤和資源耗盡錯(cuò)誤，例如Out-OfMemoryError(內(nèi)存溢出錯(cuò)誤),Java虛擬機(jī)不會(huì)檢查Error是否被處理，除了通知給用戶并且會(huì)盡力使程序安全的終止外，程序本身是無法處理這些錯(cuò)誤的。

Exception分為兩大類：運(yùn)行時(shí)異常和非運(yùn)行時(shí)異常，開發(fā)人員在代碼中應(yīng)當(dāng)盡可能去處理這些異常，從而保證程序正確執(zhí)行完畢。

下表為Exception的構(gòu)造方法和常用方法：

運(yùn)行時(shí)的異常和非運(yùn)行時(shí)的異常

各種具體的運(yùn)行時(shí)異常都是RuntimeException類或者其他子類的對(duì)象，例如ClassCase-Exception(強(qiáng)制類型轉(zhuǎn)換異常),IndexOutBoundsException(下標(biāo)越界類)等，因?yàn)檫@類異常只有在程序運(yùn)行階段才能體現(xiàn)出來，所以Java編譯器在編譯階段對(duì)代碼是否處理了該類型異常不做檢查，編譯能夠正確通過，該類異常一般是由程序邏輯錯(cuò)誤引起的，因此我們?cè)诰帉懘a的過程中應(yīng)盡可能地避免這類型的錯(cuò)誤。

常見的運(yùn)行時(shí)異常：

ArithmeticException-------->算數(shù)除法運(yùn)算中除數(shù)為0

舉例：

public class a {
    public static void main(String[]args){
        int a=10,b=0;
        System.out.println(a/b);
    }
}

ArrayIndexOutOfBoundsException----------->數(shù)組下標(biāo)超界

舉例：

public class a {
    public static void main(String[]args){
        int a[]=new int[10];
        System.out.println(a[10]);
    }
}

NumberFormatException---------->數(shù)據(jù)格式化引發(fā)的異常

public class a {
    public static void main(String[]args){
        int i=Integer.parseInt("abc");
        System.out.println(i);
    }
}

ClassCastException---------->對(duì)象類型轉(zhuǎn)換不兼容

舉例：

public class a {
    public static void main(String[]args){
        a a=new a();
        B b=(B)a;
    }
}

NullPointerException----------->空引用引發(fā)的異常 

public class a {
    public static void main(String[]args){
        a a=new a();
        a=null;
        a.getname();
    }
    public  void getname(){
        System.out.println("我是小芳");
    }
}

常見的非運(yùn)行異常：

SQLException：操作數(shù)據(jù)庫(kù)時(shí)查詢表可能發(fā)生的異常

IOException：操作文件時(shí)發(fā)生的異常

FileNotFoundException：操作不存在文件時(shí)發(fā)生的異常

ClassNotFoundException：加載類而類不存在時(shí)發(fā)生的異常

EOFException：操作文件到文件末尾發(fā)生異常

IllegalArguementException：參數(shù)異常

Java異常處理：

異常處理是指當(dāng)異常發(fā)生后，程序能夠轉(zhuǎn)向相關(guān)的異常處理代碼中并執(zhí)行嘗試性修復(fù)處理，再根據(jù)修復(fù)處理的結(jié)果決定程序的走向，使應(yīng)用程序能夠正常運(yùn)行，或降級(jí)運(yùn)行或安全地終止應(yīng)用程序的執(zhí)行，以提高應(yīng)用系統(tǒng)的可靠性。

try/catch/finally執(zhí)行情況：

try代碼段：

包含在try中的代碼段可能有多條語(yǔ)句會(huì)產(chǎn)生異常，但程序的一次執(zhí)行過程中如果產(chǎn)生異常，只可能是這些異常中的某一個(gè)，該異常對(duì)象由Java運(yùn)行時(shí)系統(tǒng)生成并拋出，try中產(chǎn)生異常語(yǔ)句，之后的語(yǔ)句都不會(huì)被執(zhí)行，如果這次執(zhí)行過程中沒有產(chǎn)生異常，那么try中所有的語(yǔ)句都會(huì)被執(zhí)行。

catch代碼段：

捕獲try中拋出的異常并在其代碼段中做相應(yīng)的處理，catch語(yǔ)句帶一個(gè)Throwable類型的參數(shù)，表示可能捕獲異常的類型。一般情況下，catch代碼段的數(shù)量由try中所拋出的異常個(gè)數(shù)決定，當(dāng)try中代碼產(chǎn)生的異常被拋出后，catch代碼段按照從上到下的書寫順序?qū)惓ｎ愋团c自己參數(shù)所指向的異常類型進(jìn)行匹配，若匹配成功程序轉(zhuǎn)而表示異常被捕獲，程序轉(zhuǎn)而執(zhí)行當(dāng)前catch中的代碼，后面所有的catch代碼段都不會(huì)被執(zhí)行，如果匹配不成功，交給下一個(gè)catch進(jìn)行匹配，如果所有catch都不匹配，表示當(dāng)前方法不具備處理該異常的能力

對(duì)于這種情況如果是一個(gè)非運(yùn)行時(shí)異常，為了編譯器通過，必須使用throws關(guān)鍵字聲明輸出。

finally代碼段：

該代碼段不是必須有的，但是如果有一定緊跟在最后一個(gè)catch代碼段后面，作為異常處理機(jī)制的統(tǒng)一出口（做善后處理）.

無論try中是否產(chǎn)生異常，finally中的代碼總在當(dāng)前方法返回之前無條件執(zhí)行。

注意：如果在某個(gè)catch代碼段中已經(jīng)執(zhí)行了要終止程序的System.exit()方法，那么此時(shí)finally中的代碼不會(huì)執(zhí)行。

throw關(guān)鍵字：

用來在方法體內(nèi)部創(chuàng)建異常對(duì)象并將其拋出，如果是非運(yùn)行時(shí)異常，還必須結(jié)合throws關(guān)鍵字在方法頭部聲明拋出該異常，表明當(dāng)前方法沒有處理該異常，將異常的處理任務(wù)延遲到當(dāng)前方法的調(diào)用者，當(dāng)前方法的調(diào)用者就必須檢查，處理，或者繼續(xù)拋出被調(diào)用方法拋出的異常

如果所有方法都層層上拋獲取的異常，最終會(huì)在main方法中尋找對(duì)應(yīng)的catch代碼段。如果main方法中也沒有對(duì)異常進(jìn)行捕獲，那么JVM將通過控制臺(tái)打印該異常消息和堆棧信息，同時(shí)程序也會(huì)終止。

throws關(guān)鍵字：

用來在方法頭部聲明方法可能會(huì)拋出的某些異常，僅當(dāng)拋出了非運(yùn)行時(shí)異常，該方法的調(diào)用者才必須處理或者重新拋出該異常。

如果方法的調(diào)用者無法處理該異常，應(yīng)該繼續(xù)拋出而不是再catch中向控制臺(tái)打印異常發(fā)生時(shí)的堆棧信息，原因是堆棧信息對(duì)于用戶來說沒什么實(shí)在的意義。

try {
    可能出現(xiàn)異常的程序代碼
    
   }catch(異常類型1 異常對(duì)象名1){
   
   異常類型1對(duì)應(yīng)的異常處理代碼
   
} catch(異常類型2 異常對(duì)象名2){

   異常類型2對(duì)應(yīng)的異常處理代碼
   
} finally{
   無論是否發(fā)生異常，程序都必須執(zhí)行的代碼(善后代碼)
}

try，catch，finally關(guān)鍵字的使用：

這三個(gè)關(guān)鍵字既可以同時(shí)出現(xiàn)在程序中，也可以兩兩組合出現(xiàn)。

try+catch：

try{
//可能拋出異常的代碼
}
catch(異常類型 異常對(duì)象名){
//針對(duì)異常的處理代碼
}

舉例：

public class a {
    public static void main(String[]args) {
        int []arr=new int[5];
        int i;
        //數(shù)組下標(biāo)為0-4的元素都根據(jù)默認(rèn)值正常輸出了，但下標(biāo)為5的元素不存在，所以便產(chǎn)生了數(shù)組下標(biāo)越界的異常
        try{
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
        }
        //隨后catch捕獲到try中產(chǎn)生的異常，catch代碼段調(diào)用異常對(duì)象的`printStackTrace()方法輸出異常發(fā)生時(shí)堆棧中的信息
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
        System.out.println("程序結(jié)束！");
    }
}

輸出：

0
0
0
0
0
程序結(jié)束！
java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
    at Employee.a.main(a.java:9)

通過打印出的堆棧信息，java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5at Employee.a.main(a.java:9)，我們可以看出具體錯(cuò)誤的信息，catch代碼段執(zhí)行完畢后，繼續(xù)執(zhí)行未執(zhí)行的代碼。

注意：catch代碼段用于處理異常，如果沒有catch代碼段就代表異常沒有被處理，如果該異常是非運(yùn)行異常，那么必須聲明輸出，否則編譯不通過

try+finally：

try{
//可能拋出異常的代碼
}
finally{
無論異常是否發(fā)生，都無條件執(zhí)行的代碼
}

舉例：

還是上述實(shí)例，我們此時(shí)將catch換成了finally：

public class a {
    public static void main(String[]args) {
        int []arr=new int[5];
        int i;
        try{
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
        }
        finally{
            System.out.println("我是finally代碼段");
        }
        System.out.println("程序結(jié)束！");
    }
}

輸出：

0
0
0
0
0
我是finally代碼段
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
    at Employee.a.main(a.java:9)

對(duì)比兩種組合輸出的結(jié)果，看起來好像是一樣的，但是仔細(xì)看，會(huì)發(fā)現(xiàn)try+finally這種組合，并沒有執(zhí)行finally下面的語(yǔ)句，也就是沒有“程序結(jié)束”該語(yǔ)句的輸出，原因即為try中發(fā)生了異常，但是該程序不存在catch代碼段去捕獲異常，所以發(fā)生異常后面的語(yǔ)句都不會(huì)被執(zhí)行。

那么有的人會(huì)說finally中的語(yǔ)句為什么可以輸出呢？

有這個(gè)疑問的小伙伴上去再看一下finally的用法。

try+catch+finally：

try{
//可能拋出異常的代碼
}
catch(異常類型 異常對(duì)象名){
//針對(duì)異常的處理代碼
}finally{
無論異常是否發(fā)生，都無條件執(zhí)行的代碼
}

舉例：

public class a {
    public static void main(String[]args) {
        int []arr=new int[5];
        int i;
        try{
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
        }
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
        finally{
            System.out.println("我是finally代碼段");
        }
        System.out.println("程序結(jié)束！");
    }
}

輸出：

0
0
0
0
0
我是finally代碼段
程序結(jié)束！
java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
    at Employee.a.main(a.java:9)

這種組合輸出，當(dāng)發(fā)生異常由catch捕獲處理完異常之后，繼續(xù)執(zhí)行下面未執(zhí)行完的語(yǔ)句。

注意?。?！

1：finally代碼段與其上面的catch代碼段之間不能再添加其他代碼語(yǔ)句。

2：try,finally這種形式由于沒有對(duì)異常進(jìn)行任何的處理，所以一般不會(huì)應(yīng)用在實(shí)際開發(fā)中。

trows和throw關(guān)鍵字的使用：

throws關(guān)鍵字的使用：

如果當(dāng)前方法不對(duì)異常進(jìn)行處理，可以通過聲明拋出異常，將處理該異常的任務(wù)交給當(dāng)前方法的調(diào)用者，throws用在方法聲明部分的結(jié)尾處，表示該方法拋出異常，一個(gè)方法可以聲明拋出多個(gè)異常，這取決于方法中可能產(chǎn)生的異常個(gè)數(shù)，如果拋出多個(gè)異常，那么這些多個(gè)異常之間用逗號(hào)隔開，一個(gè)聲明了拋出異常的方法定義格式如下：

[修飾符] 返回值類型 方法名([參數(shù)列表])[throws 異常列表]{
   //  方法體;
}      

舉例：

public class a {
    public static void print() throws ArrayIndexOutOfBoundsException{
        int []arr=new int[5];
        int i;
//print()方法體并沒有使用try-catch對(duì)ArrayIndexOutOfBoundsException異常進(jìn)行處理，而是通過throws關(guān)鍵字聲明拋出
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
    }
    public static void main(String[]args)throws ArrayIndexOutOfBoundsException{
    //main()方法中對(duì)print()方法進(jìn)行了調(diào)用，通過try-catch方式對(duì)print()方法拋出的異常進(jìn)行捕獲處理。
        try{
            print();
        }
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
    }
}

輸出：

0
0
0
0
0
java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
    at Employee.a.print(a.java:9)
    at Employee.a.main(a.java:13)

當(dāng)然main方法也可以不用try-catch方式處理，而是繼續(xù)通過trows關(guān)鍵字拋出。

那么運(yùn)行結(jié)果通過運(yùn)行結(jié)果，我們能夠了解什么信息呢？

首先通過輸出信息的最上部（異常入棧時(shí)位于棧底）入手去源文件中查找異常產(chǎn)生的原因。那么在本例中，我們通at Employee.a.print(a.java:9)，應(yīng)該去第九行尋找原因！

注意?。?！

如果一個(gè)方法通過trows聲明拋出了異常，那么調(diào)用該方法的其他方法可以通過try-catch方式進(jìn)行捕獲處理，也可以繼續(xù)通過throws聲明將異常拋出。

一般不建議在main方法中通過trows聲明拋出異常原因?yàn)椋篔ava中發(fā)生異常如果一直上拋，最終拋給了main方法，main方法繼續(xù)上拋，拋給了調(diào)用者JVM，JVM終止程序的執(zhí)行。

這樣看來好像也沒什么錯(cuò)，但是異常處理機(jī)制的作用就是提高程序的健壯性，保證程序出現(xiàn)了異常也能執(zhí)行，所以main方法中的異常建議是使用try-catch進(jìn)行捕捉，而不是繼續(xù)上拋！

trow關(guān)鍵字的使用：

throw關(guān)鍵字主要用在方法體中對(duì)異常進(jìn)行拋出，通常方法體中捕獲到相關(guān)異常對(duì)象后并不進(jìn)行處理，將對(duì)象的處理交給當(dāng)前方法的調(diào)用者，一個(gè)通過trow關(guān)鍵字聲明拋出異常的方法定義格式如下：

[修飾符] 返回值類型 方法名([參數(shù)列表])[throws 異常列表]{
   //  方法體;
   trow異常對(duì)象；
}  

舉例：

public class a { 
    public static void print(){
        int []arr=new int[5];
        int i;
        try{
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
        }
        //該catch并沒有對(duì)異常進(jìn)行處理，而是通過trow將異常對(duì)象拋出了
        catch(ArrayIndexOutOfBoundsException e){
            throw e;
        }
    }
    public static void main(String[]args){
        try{
            print();
        }
        //main方法中的catch捕獲到try中調(diào)用print方法的異常并對(duì)其進(jìn)行處理
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
    }
}

輸出：

0
0
0
0
0
java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
    at Employee.a.print(a.java:8)
    at Employee.a.main(a.java:16)

提醒：

由于這里的ArrayIndexOutOfBoundsException是運(yùn)行時(shí)異常，所以print()方法聲明部分的結(jié)尾不再需要throws，如果throw拋出的是某個(gè)非運(yùn)行異常，那么throw所在的方法的聲明尾部還需要通過throws聲明將這個(gè)非運(yùn)行時(shí)異常對(duì)象拋出。

自定義異常：

在實(shí)際開發(fā)中，異常正所謂是“千姿百態(tài)”，但JDK提供給我們的異常類型是很有限的，因此面對(duì)實(shí)際開發(fā)中的各種異常問題，我們除了靈活使用JDK提供給我們的之外，還需要我們自定義一些異常，這些異常也就是我們?cè)诿嫦驅(qū)ο缶幊痰倪^程中，出現(xiàn)的特有問題。

既然是自定義，那么由于每個(gè)人想法和處理問題的方式不同，很容易出現(xiàn)操作異常等問題，為了解決這種問題，我們規(guī)定自定義異常必須繼承Exception或者RuntimeException，從Exception繼承表示自定義異常是非運(yùn)行時(shí)異常，從RuntimeException繼承表示自定義異常是運(yùn)行時(shí)異常，當(dāng)腰操作自定義異常的信息時(shí)，可以使用父類已經(jīng)定義好的方法

自定義異常的一般形式如下：

class 異常類名 extends Exception|RunException
{
//類體
}

舉例：

當(dāng)輸入的分?jǐn)?shù)小于0時(shí)，捕獲異常并輸出分?jǐn)?shù)不能小于0的提示信息。

主類：

package exception;

import java.util.Scanner;

public class exception {
   public static  void show_score() throws Text {
   //該方法并沒有對(duì)分?jǐn)?shù)小于0的這種情況進(jìn)行任何的處理，而是創(chuàng)建異常對(duì)象將它拋出
       int score;
       Scanner scanner=new Scanner(System.in);
       score=scanner.nextInt();
       if(score<0){
           throw new Text("分?jǐn)?shù)不能小于0");
       }
   }
    public static void main(String[]args){
    //在main方法中捕獲到該異常，并對(duì)其進(jìn)行處理
        try{
            show_score();
        } catch (Text e) {
            e.printStackTrace();
        }
    }
}

由于JDK并沒有為我們提供某一個(gè)異常來描述分?jǐn)?shù)不能小于0的這種情況，所以需要自定義異常類[這里的異常類為Text類]來表示分?jǐn)?shù)不能小于0的這種情況，且該異常是非運(yùn)行異常，因此需要繼承Exception類。

自定義異常類：

package exception;

public class Text extends Exception{
    public Text(String message) {
        super(message);
    }
}

輸出：

注意：如果該異常屬于RuntimeException，那么在方法的尾部不需要throws聲明將該異常拋出，反之如果是Exception，則需要聲明拋出

異常處理事項(xiàng)：

如果一個(gè)方法產(chǎn)生的異常不止一種，且這些異常具有父子關(guān)系，那么書寫catch代碼塊時(shí)，處理異常的catch塊要位于處理子異常catch塊的后面。

依然是上述事例：

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

由于Text異常類繼承了Exception類，所以處理父類Exception類的catch代碼塊必須寫在子類Text的后面。

在進(jìn)行方法覆蓋時(shí)，如果被覆蓋的方法拋出異常，那么覆蓋方法可以不拋異常，或者拋與被覆蓋方法相同的異常，或者拋被覆蓋方法的所拋異常的子異常。

定義父類拋出Exception類異常：

package exception;

public class Father {
    public void show() throws Exception{
        int a=10;
       if(a<100){
           throw new Exception();
       }
        System.out.println("hello，Java");
    }
}

子類對(duì)象對(duì)父類中的show方法進(jìn)行覆蓋：

package exception;

public class Son extends Father{
  @Override
    public void show() throws Exception {
        System.out.println("helloJava");//拋出和父類相同的異常
    }
  @Override
    public void show() throws Text{//拋出父類拋出的異常的子異常類
        System.out.println("helloJava");
    }
      @Override
    public void show() {//未拋出異常
        System.out.println("helloJava");
    }
}

以上三種方式均正確！

如果try代碼中有return語(yǔ)句返回基本數(shù)據(jù)類型變量，即使finally中對(duì)該基本數(shù)據(jù)類型變量進(jìn)行修改，返回結(jié)果以try中修改的值為準(zhǔn)。

舉例：

package exception;

import java.util.Scanner;

public class exception {
   private static int getnumber(){
       int i=0;
       try{
           i=100;
           return i;
       }catch (Exception e){
           e.printStackTrace();
       }finally//在finally中改變基本數(shù)據(jù)類型變量i的值
           i=1000;
       }
       return i;
    }
    public static void main(String[]args){
        System.out.println(getnumber());
    }
}

輸出：

100//try中的值

如果try代碼中有return語(yǔ)句，返回引用數(shù)據(jù)類型變量，finally中對(duì)該引用數(shù)據(jù)類型變量進(jìn)行修改，返回結(jié)果以finally中修改的值為準(zhǔn)。

舉例：

package exception;

import java.util.Scanner;

public class exception {
    String name;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
private static exception getname(){
        exception exception=new exception();
        try{
            exception.setName("張三");
            return exception;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            exception.setName("小張");
        }return exception;
}

        public static void main(String[]args){
            System.out.println(getname().getName());
        }
}

輸出：

李四//finally中的值

如果try，finally代碼中都有return語(yǔ)句，無論返回什么數(shù)據(jù)類型，返回結(jié)果以finally中修改的值為準(zhǔn)。

舉例：

package exception;

import java.util.Scanner;

public class exception {
    String name;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
private static exception getname(){
//try和finally語(yǔ)句中都含有return語(yǔ)句
        exception exception=new exception();
        try{
            exception.setName("張三");
            return exception;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            exception.setName("小張");
            return exception;
        }
}
        public static void main(String[]args){
            System.out.println(getname().getName());
        }
}

輸出：

小張//finally中的值

總結(jié)

到此這篇關(guān)于Java異常處理機(jī)制知識(shí)整理的文章就介紹到這了,更多相關(guān)Java異常處理機(jī)制內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！