Java中Exception異常機制的原理

本篇文章給大家分享的是有關Java中Exception異常機制的原理，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

Error與Exception的區(qū)別與相同點：

• Error是嚴重的錯誤，并非異常，錯誤是無法通過編碼解決的。

• Exception是異常，異常則是可以通過編碼解決的。

Error與Exception的相同點：

• Error與Exception類都是Throwable的子類

Exception類是所有異常的超類。

Java所有的異常在尋找父類的時候最終都能找到Exception類。

異常的分類

java.lang.Exception類是所有異常的超類，主要分為以下兩種:

RuntimeException-運行時異常，也叫作非檢測性異常.

lOException和其它異常-其它異常，也叫作檢測性異常，所謂檢測性異常就是指在編譯階段都能被編譯器檢測出來的異常。
其中RuntimeException類的主要子類︰ArithmeticException類-算術異常，ArraylndexOutOfBoundsException類-數(shù)組下標越界異常，NullPointerException-空指針異常，ClassCastException-類型轉換異常，NumberEormatException-數(shù)字格式異常注意:
當程序執(zhí)行過程中發(fā)生異常但又沒有手動處理時，則由Java虛擬機采用默認方式處理異常，而默認處理方式就是︰打印異常的名稱、異常發(fā)生的原因、異常發(fā)生的位置以及終止程序。

二、關于RuntimeException

非檢測性異常

package com.sinsy.exception;

public class ExceptionTest {
    public static void main(String[] args) {
        // 非檢測性異常 ： Exception in thread "main" java.lang.ArithmeticException: / by zero jvm無法檢測
        System.out.println(5 / 0);
        //檢測型異常
        Thread.sleep(3000);
    }
}

RuntimeException的主要子類有：

• ArithmeticException–算數(shù)異常

• ArrayIndexOutOfBoundsException–數(shù)組下標越界異常

• NullPointerException–空指針異常

• ClassCastException–類型轉換異常

• NumberFormatException–數(shù)字格式異常

下面通過代碼來對異常做出解釋：

為了讓所有的異常都能正常的顯示出來，我這里對每一種異常使用多線程來打印輸出：

package com.sinsy.exception;
public class ExceptionTest {
    public static void main(String[] args) throws Exception {
        // 非檢測性異常 ： Exception in thread "main" java.lang.ArithmeticException: / by zero jvm無法檢測
        // System.out.println(5 / 0);
        //檢測型異常
        //Thread.sleep(3000);
        exceptionTest();
    }
    public static void exceptionTest(){
       new Thread(new Runnable() {
           @Override
           public void run() {
               //第一種 數(shù)組下標越界異常
               int arr[] = new int[5];
               System.out.println(arr[5]);
           }
       }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                //算數(shù)異常
                int a = 1;
                int b = 0;
                System.out.println(a/b);
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                //空指針異常
                String abc = null;
                System.out.println(abc.length());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                //類型轉換異常
                Exception exception = new Exception();
                InterruptedException interruptedException =(InterruptedException) exception;
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                //數(shù)字格式異常
                String ad = "1234a";
                System.out.println(Integer.parseInt(ad));
            }
        }).start();
    }
}

運行之后的結果為：很清晰的看見，每一個線程代表著一種異常。

通過編碼對各種異常進行處理之后，結果為：

/**
 * 測試各種異常轉換機制的修復
 */
public static void exceptionModifyTest(){
    new Thread(() -> {
        //第一種 數(shù)組下標越界異常
        int arr[] = new int[5];
        if (arr.length>5){
        System.out.println(arr[5]);
        }
        System.out.println("下標越界異常已經規(guī)避");
    }).start();
    new Thread(new Runnable() {
        @Override
        public void run() {
            //算數(shù)異常
        int a = 1;
        int b = 0;
        if (0!=b){
        System.out.println(a/b);
        }
            System.out.println("算術異常已經規(guī)避");
        }
    }).start();
    new Thread(() -> {
        //空指針異常
        String abc = null;
        if (null!=abc) {
            System.out.println(abc.length());
        }
        System.out.println("空指針異常已經規(guī)避");
    }).start();
    new Thread(() -> {
        //類型轉換異常
        Exception exception = new Exception();
        if (exception instanceof  InterruptedException) {
            InterruptedException interruptedException = (InterruptedException) exception;
        }
        System.out.println("類型轉換異常已經規(guī)避");
    }).start();
    new Thread(() -> {
        //數(shù)字格式異常
        String ad = "1234a";
        //字符串類型的數(shù)據(jù)做篩選一般選擇正則表達式做第一選擇
        if (ad.matches("\\d+")){
        System.out.println(Integer.parseInt(ad));
        }
        System.out.println("數(shù)字格式異常已避免");
    }).start();
}

運行結果為：

三、異常的避免

異常的避免其實上文已經凸顯出來了結局方案，就是在可能出現(xiàn)異常的地方進行if判斷處理，提前預判異常，然后對可能出現(xiàn)的異常跳過處理。

異常的避免（使用If-else）可能會導致大量的代碼冗余，導致代碼的沉積度過大，變得臃腫，可讀性比較差。

四、異常的捕獲

異常的捕獲使用try{}catch{}來進行捕獲

捕獲不了的我們對其進行拋出

五、異常的拋出（異常的轉移）

異常拋出拋給誰呢？當然是異常的捕獲者。

異常拋出的時候需要注意一點，拋出的異常之間有父子類繼承關系的，如果跑的異常包含多個，那么我們可以選擇拋出異常最大的父類，直接可以拋出所有異常，這樣節(jié)省了代碼，但同時也對代碼的可讀性造成了一定的影響，讓修改者無法直接得知此代碼在使用過程中會出現(xiàn)什么樣的異常。

基本概念

在某些特殊情況下有些異常不能處理或者不便于處理時，就可以將該異常轉秘給該方法的調用者，這種方法就叫異常的拋出，本質上其實是異常的轉移。方法執(zhí)行時出現(xiàn)異常，則底層生成一個異常類對象拋出，此時異常代碼后續(xù)的代碼就不再執(zhí)行。

語法格式

訪問權限返回值類型方法名稱(形參列表) throws異常類型1,異常類型2…{方法體;}如︰
public void show() throws lOExceptiont

方法重寫的原則

a.要求方法名相同、參數(shù)列表相同以及返回值類型相同，從jdk1.5開始支持返回子類類型;b.要求方法的訪問權限不能變小，可以相同或者變大;
c.要求方法不能拋出更大的異常;

注意

子類重寫的方法不能拋出更大的異常、不能拋出平級不一樣的異常，但可以拋出一樣的異常、更小的異常以及不拋出異常。一定注意?。。。。。。。。?！若父類中被重寫的方法沒有拋出異常時，則子類中重寫的方法只能進行異常的捕獲。不建議在Main方法中拋出異常，JVM需要執(zhí)行的任務有很多，如果此時將大量的異常工作交給他來做，那么會影響JVMd額執(zhí)行效率

異常的常規(guī)處理

對于常見的異常，通常對不同類型的異常有著不同的處理方法.

（1）如果父類方法拋出了異常，子類不能拋出比父類更大的異常，只能拋出與父類所拋異常類子類的異常，特殊情況可不拋出任何異常。

• 父類拋出InterruptedException與IOException，子類只拋出InterruptedException，不拋出IOException

/**
 * 父類
 */
package com.sinsy.test;
import java.io.FileInputStream;
import java.io.IOException;
public class ThrowExceptionFather {
    public  void show() throws IOException, InterruptedException {
        Thread.sleep(100);
        System.out.println("hehehe");
        FileInputStream fileInputStream =new FileInputStream("");
        fileInputStream.close();
    }
}
/**
 * 子類	
 */
package com.sinsy.test;
public class ThrowExceptionTest extends ThrowExceptionFather{
    @Override
    public void show() throws InterruptedException {
        Thread.sleep(20);
    }
}

• 父類的原始方法只拋出IOExeption，而子類在重寫該方法的時候拋出父類中沒有的異常，并且該異常與父類所拋異常并非同屬某一類的子類，也就是說子類所拋出的異常與父類所拋出的異常并不是同一級。

/**
 * 父類
 */
package com.sinsy.test;
import java.io.FileInputStream;
import java.io.IOException;
public class ThrowExceptionFather {
    public  void show() throws IOException {
        FileInputStream fileInputStream =new FileInputStream("");
        fileInputStream.close();
    }
}

/**
 * 子類
 */
package com.sinsy.test;
public class ThrowExceptionTest extends ThrowExceptionFather{
    @Override
    public void show() throws InterruptedException {
        Thread.sleep(20);
    }
}

此時代碼報錯，證明子類無法拋出與父類非同級關系的異常：

• 父類只拋出一個異常，子類拋出與父類所拋異常同級但不同的異常：如下代碼：子類拋出了一個與父類方法中同級別的異常但父類并未拋出該異常，此時代碼報錯：證明子類不可拋出與父類同級別的異常：（ClassNotLoadedException與IOException屬于同一級別）

/**
 * 父類
 */
package com.sinsy.test;
import com.sun.jdi.ClassNotLoadedException;
import java.io.FileInputStream;
import java.io.IOException;
public class ThrowExceptionFather {
    public  void show() throws IOException {
        FileInputStream fileInputStream =new FileInputStream("");
        fileInputStream.close();
    }
}

/**
 * 子類
 */
package com.sinsy.test;
import com.sun.jdi.ClassNotLoadedException;
public class ThrowExceptionTest extends ThrowExceptionFather{
    @Override
    public void show() throws ClassNotLoadedException {
    }
}

但是子類可以拋出一個是父類所拋異常類的子類的異常：

通過對比IOException的簡單繼承關系我們可以選擇一個IOException的子類，讓繼承了ThrowExceptionFather的子類在方法重寫的時候去拋出該異常，如下代碼：

package com.sinsy.test;

import com.sun.jdi.ClassNotLoadedException;

import java.nio.file.FileSystemException;

public class ThrowExceptionTest extends ThrowExceptionFather{
    @Override
    public void show() throws FileSystemException {

    }
}

此時未報錯：

證明，子類可以拋出父類所拋異常類子類的異常。

因此，總結一句話就是：子類繼承父類后，在重寫父類方法的時候，如果父類中原有方法拋出了異常，那么子類不能拋出比父類所拋異常大的異常，只能拋出屬于父類所拋異常類的子類的異常。

（2）若一個方法內部以遞進式的方法分別調用了好幾個其他的方法，則建議這些方法將異常逐層拋出，然后再統(tǒng)一處理。如下代碼所示。

package com.sinsy.test;
public class DigonThrow {
    public static void yu() {
        try {
            yu1();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void yu1() throws Exception {
        yu2();
    }
    public static void yu2() throws Exception {
        yu3();
    }
    public static void yu3() throws Exception {
        yu4();
    }
    public static void yu4() throws Exception {
      yu5();
    }
    public static void yu5()throws Exception{
        System.out.println(1);
    }
    public static void main(String[] args){
        yu();
    }
}

將異常拋至最頂層的時候，此時做最后的 try-catch 處理。

（3）如果父類中被重寫的方法沒有拋出異常的時候，則子類中重寫的方法只能進行異常的捕獲處理。

//父類代碼
package com.sinsy.test;
public class ThrowExceptionFather {
    public  void show(){

    }
}
//子類代碼
package com.sinsy.test;
import java.io.FileInputStream;
import java.io.IOException;

public class ThrowExceptionTest extends ThrowExceptionFather{
    @Override
    public void show() {
        FileInputStream fileInputStream =new FileInputStream("");
        fileInputStream.close();
    }
}

若此時子類拋出異常，則會出現(xiàn)以下警示：

Method ‘show' is inherited.Do you want to add exceptions to method signatures in the whole method hierarchy?意思就是在說，方法‘Show'是繼承的。要在整個方法層次結構中向方法簽名添加異常嗎？如果添加了之后，則父類中過就會拋出此異常！

六、自定義異常

基本概念

當需要在程序中表達年齡不合理的情況時，而Java官方又沒有提供這種針對性的異常，此時就需要程序員自定義異常加以描述。

實現(xiàn)流程

a.自定義xxxException異常類繼承Exception類或者其子類。
b.提供兩個版本的構造方法，一個是在·無參構造方法，另外一個是字符電作為參數(shù)的構造方法。

異常的產生

throw new異常類型(實參);如∶throw new AgeException("年齡不合理!!! ");Java采用的異常處理機制，是將異常處理的程序代碼集中在一起，與正常的程序代碼分開**，使得程序簡潔、優(yōu)雅，并易于維護。**

自定義Exception異常類

要想實現(xiàn)自定義Exception異常類，我們需要寫一個Exception的異常類去繼承Exception類，實現(xiàn)無參構造方法以及有參數(shù)構造方法。

package com.sinsy.exception;

public class AgeException extends Exception{
    
    static final long serialVersionUID = -3387516993124229948L;

    /**
     * 無參數(shù)構造方法
     */
    public AgeException() {
    }

    /**
     * 有參構造方法
     * @param message
     */
    public AgeException(String message) {
        super(message);
    }
}

• 自定義Exception異常類的使用：

（1）首先確定應用場景為：用戶個人信息的封裝中，對成員屬性的封裝的時候對成員屬性的設置出現(xiàn)異常：

package com.sinsy.bean;
import com.sinsy.exception.AgeException;
import java.util.Objects;
public class Person {
    private String name;
    private String sex;
    private int age;
    public Person() {
    }
    public Person(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) throws AgeException {
        if (age<0){
            throw new AgeException("年齡設置錯誤哦！請稍后重試!");
        }else{
            this.age = age;
        }
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name) && Objects.equals(sex, person.sex);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, sex, age);
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
}

（2）確定引用場景之后，我們創(chuàng)建Test測試方法對目標用例進行簡單測試：

package com.sinsy.test;

import com.sinsy.bean.Person;
import com.sinsy.exception.AgeException;

public class PersonException {
    public static void main(String[] args) {
        Person person = new Person("二狗子");
        try {
            person.setAge(-12);
        }catch (AgeException ageException){
            ageException.printStackTrace();
        }
        System.out.println("執(zhí)行完畢");
    }
}

測試結果如下：

這表明，AgeException的異常類使用正確，正確的打印出來了錯誤提示信息，這里的錯誤提示信息是自己自定義的，也就是你在調用AgeException類的時候自己輸入的異常提示信息。這就是調用了AgeExceptiuon類的默認含參數(shù)的構造方法。

注意含有異常處理的代碼執(zhí)行順序：

在遇到異常的時候我們需要根據(jù)異常出現(xiàn)的具體應用場景作相應的處理，如果是重寫父類的繼承下來的方法，我們在對方法進行重寫的時候，我們需要注意，如果父類的原始方法并沒有拋出異常，在子類中重寫父類的方法是不需要拋出異常的，否則則會報錯，而在處理異常的時候，我們更需要關注的是異常出現(xiàn)的位置以及時機。如果異常出現(xiàn)在可預測區(qū)域，則主動應該拋出對應可能會出現(xiàn)的異常，讓代碼安全的執(zhí)行，不產生額外的錯誤。其二，在處理異常的時候，如果是遞進式拋出異常，在最頂層的時候一定要try-catch處理異常，不可再向上拋出，如果拋給虛擬機來處理，那么則會響應JVM的執(zhí)行效率。其三，當處理異常的時候，如果我們遇到與異常耦合度不高的業(yè)務需要執(zhí)行的時候，我們可以在finally中編寫與異常無耦合度的代碼，確保必要的有業(yè)務能正常執(zhí)行。

處理異常的時候由于finally與try-catch的關系，有時候會打亂原有代碼的執(zhí)行順序，也會間接影響業(yè)務的執(zhí)行：比如以下處理方法的不同導致在業(yè)務最后的結果完全不一致。代碼如下

package com.sinsy.test;
import com.sinsy.bean.Person;
import com.sinsy.exception.AgeException;
public class PersonException {
    public static void main(String[] args) {
        Person person = new Person("二狗子");
        //注意我這里的處理異常的方式方法： 是在最頂層拿到異常之后直接當場做的處理，
        try {
            person.setAge(-12);
        }catch (AgeException ageException){
            //這里就是處理 直接將異常打印輸出
            ageException.printStackTrace();
        }
        System.out.println("執(zhí)行完畢");
    }
}

處理之后的結果為：

**而如果我們將代碼做一個簡單的修改：**在設置年齡的2時候我們不對錯誤年齡進行拋出異常處理而是直接就地處理。則會怎么樣呢？為了讓效果更加明顯，我們將SetAge的方法修改完之后我們再繼續(xù)將測試方法中測試用例做一個簡單的更改：

public void setAge(int age) {
    if (age<0){
       try {
           throw new AgeException("年齡設置錯誤哦！請稍后重試!");
       }catch (AgeException ageException){
           ageException.printStackTrace();
       }
    }else{
        this.age = age;
    }
}

//測試方法：
package com.sinsy.test;
import com.sinsy.bean.Person;
import com.sinsy.exception.AgeException;
public class PersonException {
    public static void main(String[] args) {
        Person person = new Person("二狗子","男");
        //注意我這里的處理異常的方式方法： 是在最頂層拿到異常之后直接當場做的處理，
        person.setAge(-12);
        System.out.println(person);
    }
}

最后的處理結果：

以上就是Java中Exception異常機制的原理，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業(yè)資訊頻道。