代碼在運行中發生的問題就是異常

java中把多種異常封裝多個類，當程序出現問題時候，就會創建異常類對象並且拋出相關信息

異常體系：

Throwable類是Java中所有錯誤或異常的父類

Throwable的子類Error類是所有錯誤的父類

Throwable的另一個子類Exception類是所有異常的父類

在開發中，相對來說，我們並不關心錯誤，而更關心異常

異常和錯誤的區別（通俗解釋）：

異常：相當於一個人感冒了，吃藥睡覺等進行相應的操作即可痊愈，不修改代碼處理掉異常，程序還可以執行

錯誤：相當於一個人得了絕癥，無法治愈，必須修改代碼，程序才可以執行

所以可以這樣理解：我們並不關心患了絕癥的人，而會想方法去治愈得了小病的人

示例：‘

package demo;

public class Demo {
    public static void main(String[] args) {
        function1();
        function2();
    }
    public static void function1(){
        //異常
        int[] arr = {1,2};
        System.out.println(arr[3]);
        //輸出：
        //Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
        
 
//at demo.Demo.function1(Demo.java:11)
        //at demo.Demo.main(Demo.java:5)
    }
    public static void function2(){
        //錯誤
        int[] arr = new int[666666666];
        System.out.println(arr);
        //輸出：
        //Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        
 
//at demo.Demo.function2(Demo.java:19)
        //at demo.Demo.main(Demo.java:6)
    }
}

一旦異常被拋出了，後邊的程序都不會執行，因此要想辦法解決這個問題

異常中的關鍵字throw：

寫一段代碼，存在空指針異常

package demo;

public class ExceptionDemo {
    public static void main(String[] args) {
        int [] arr = null;
        function(arr);
    }
    public static int function(int[] arr){
        int i = arr[arr.length-1];
        return i;
    }
}

加入throw關鍵字，拋出異常：

package demo;

public class ExceptionDemo {
    public static void main(String[] args) throws Exception {
        int [] arr = null;
        int i = function(arr);
        System.out.println(i);
    }
    public static int function(int[] arr) throws Exception{
        //如果方法中有異常，需要在方法上聲明：throws Exception
        //拋出的類型和聲明的異常類應當一致
        //main調用這個方法，也需要加入聲明
        if(arr == null){
            //拋出異常，告訴調用者
            //手動拋出異常
            throw new Exception("傳遞數組不存在");
        }
        if(arr.length == 0){
            throw new Exception("傳遞的數組中沒有元素");
        }
        int i = arr[arr.length-1];
        return i;
    }
}
/*
輸出：
Exception in thread "main" java.lang.Exception: 傳遞數組不存在
at demo.ExceptionDemo.function(ExceptionDemo.java:16)
at demo.ExceptionDemo.main(ExceptionDemo.java:6)
*/

這裏註意，如果是運行時異常（RuntimeException），不需要throws聲明 ，

而且如果發生這種異常，那麽必須改代碼，否則代碼無意義

try catch方法異常處理：

package demo;

public class ExceptionDemo {
    public static void main(String[] args) {
        int[] arr = null;
        try {
            int i = function(arr);
            System.out.println(i);
        } catch (NullPointerException ex) {
            System.out.println(ex);
        } catch (ArrayIndexOutOfBoundsException ex) {
            System.out.println(ex);
        }
        System.out.println("結束");
    }

    public static int function(int[] arr) throws NullPointerException, ArrayIndexOutOfBoundsException {
        if (arr == null) {
            // 手動拋出空指針異常
            throw new NullPointerException("數組不存在");
        }
        if (arr.length < 6) {
            // 手動拋出數組索引越界異常
            throw new ArrayIndexOutOfBoundsException("數組沒有6索引");
        }
        return arr[6];
    }
}
/*
輸出：
java.lang.NullPointerException: 數組不存在
結束
 */

這裏發現，雖然程序有異常，但是依然執行後面的代碼，這就是異常處理

catch的順序：

平級：

package demo;/*
 * catch處理的註意事項：
 *   有順序
 *   當異常是平級的時候，即沒有繼承關系的時候，沒有順序限制 
 */
public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            
        } catch (NullPointerException e) {

        } catch (ArrayIndexOutOfBoundsException e) {
            
        }
    }
}

有繼承關系：

package demo;
//有繼承關系：越高級的寫在越靠後
public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            
        } catch (NullPointerException ex) {

        } catch (RuntimeException ex) {
            
        } catch (Exception ex){
            
        }
    }
}

finally:

package demo;

//finally:必須執行
//是否有異常都會執行
public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            function(1);
        } catch (Exception ex) {
            System.out.println(ex);
        } finally {
            System.out.println("代碼必須執行");
        }
    }

    public static void function(int a) throws Exception {
        if (a == 0) {
            throw new Exception();
        }
        System.out.println(a);
    }
}
//無論傳入什麽，都會輸出：代碼必須執行

註意事項：

1.父類的方法如果拋出異常，子類重寫後可以不拋出異常，但是子類如果要拋出異常，這個異常的繼承關系不能大於父類的異常

自定義異常：

有時候需要一些自定義的異常，這裏做一個示例：

package demo;

public class FuShuException extends RuntimeException {
    public FuShuException(String string){
        super(string);
    }
    public FuShuException(){}
}

package demo;

//設置一個情景，計算兩門成績的平均數，不能為負數
//如果是一個負數，就拋出異常
public class ExceptionDeno {
    public static void main(String[] args) throws FuShuException {
        try {
            int i = function(10, 97);
            System.out.println(i);
        } catch (FuShuException ex) {
            ex.printStackTrace();
        }
    }

    public static int function(int a, int b) throws FuShuException {
        if (a < 0 || b < 0) {
            throw new FuShuException("成績不為負");
        }
        int sum = a + b;
        return sum / 2;
    }
}

Java學習筆記35（異常）