異常的基本概念：

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

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

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

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

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

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

3：按錯誤類型和錯誤差別分組

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

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

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

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

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

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

2：用于描述異常或錯誤出現(xiàn)位置的消息字符串。

3：異常或錯誤產(chǎn)生的原因

Throwable有兩個直接子類：Error和Exception，分別表示錯誤和異常，其中異常Exception又包括兩大類：運行時異常(RuntimeException)和非運行時異常。

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

Error與Exception:

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

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

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

運行時的異常和非運行時的異常

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

常見的運行時異常：

ArithmeticException-------->算數(shù)除法運算中除數(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---------->對象類型轉(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("我是小芳");
    }
}

常見的非運行異常：

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

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

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

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

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

IllegalArguementException：參數(shù)異常

Java異常處理：

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

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

try代碼段：

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

catch代碼段：

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

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

finally代碼段：

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

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

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

throw關(guān)鍵字：

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

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

throws關(guān)鍵字：

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

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

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

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

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

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

try+catch：

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

舉例：

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)用異常對象的`printStackTrace()方法輸出異常發(fā)生時堆棧中的信息
        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)，我們可以看出具體錯誤的信息，catch代碼段執(zhí)行完畢后，繼續(xù)執(zhí)行未執(zhí)行的代碼。

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

try+finally：

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

舉例：

還是上述實例，我們此時將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)

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

那么有的人會說finally中的語句為什么可以輸出呢？

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

try+catch+finally：

try{
//可能拋出異常的代碼
}
catch(異常類型 異常對象名){
//針對異常的處理代碼
}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í)行完的語句。

注意?。。?/strong>

public class a {
    public static void print() throws ArrayIndexOutOfBoundsException{
        int []arr=new int[5];
        int i;
//print()方法體并沒有使用try-catch對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()方法中對print()方法進(jìn)行了調(diào)用，通過try-catch方式對print()方法拋出的異常進(jìn)行捕獲處理。
        try{
            print();
        }
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
    }
}

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并沒有對異常進(jìn)行處理，而是通過trow將異常對象拋出了
        catch(ArrayIndexOutOfBoundsException e){
            throw e;
        }
    }
    public static void main(String[]args){
        try{
            print();
        }
        //main方法中的catch捕獲到try中調(diào)用print方法的異常并對其進(jìn)行處理
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
    }
}

package exception;

import java.util.Scanner;

public class exception {
   public static  void show_score() throws Text {
   //該方法并沒有對分?jǐn)?shù)小于0的這種情況進(jìn)行任何的處理，而是創(chuàng)建異常對象將它拋出
       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方法中捕獲到該異常，并對其進(jìn)行處理
        try{
            show_score();
        } catch (Text e) {
            e.printStackTrace();
        }
    }
}

package exception;

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

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

package exception;

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

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");
    }
}

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());
    }
}

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());
        }
}

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語句中都含有return語句
        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());
        }
}