碼文異常不要怕，一篇文章精通應對【Java】中的異常

個人名片：

🐼作者簡介：一名大一在校生🎏 🐻‍❄️個人首頁：小新愛學習.

🕊️系列專欄：零基礎學java ----- 重識c語言

🐓每日一句：星光不問趕路人，時光不負有心人！

文章目錄

1. 異常💥

1.1 異常概述🎊

1.1.1Error🐧
1.1.2Exception的層次🐯

1.2 JVM的預設處理方案🎉
1.3 異常處理🐷
1.4 異常處理之 try... catch...（捕獲異常）🦖
1.5 多重捕獲🐶
1.6 異常方法（Throwable的成員方法）🦜
1.7 編譯時異常和運作時異常的差別🐢
1.8 異常處理之throws🐬
1.9 聲明自定義異常🦀
2.0 throw和throws的差別🐣
2.1 finally關鍵字🦋
2.2 通用異常✨

1. 異常💥

1.1 異常概述🎊

異常：就是程式出現了不正常的情況

異常體系：

Error：嚴重問題，不需要處理。

Exception：稱為異常類，他表示程式本身可以處理的問題。

RuntimeException:在編譯期是不檢查的，出問題後，需要我們回來修改代碼。
非RuntimeException：編譯期間就必須處理，否則程式不能通過編譯，就更不能正常運作

異常：索引越界

所有的異常類是從 java.lang.Exception 類繼承的子類。

public class Throwable

extends Object

implements Serializable

Throwable 類是 Java 語言中所有錯誤或異常的超類。隻有當對象是此類（或其子類之一）的執行個體時，才能通過 Java 虛拟機或者 Java throw 語句抛出。類似地，隻有此類或其子類之一才可以是 catch 子句中的參數類型。

兩個子類的執行個體，Error 和 Exception，通常用于訓示發生了異常情況。通常，這些執行個體是在異常情況的上下文中新近建立的，是以包含了相關的資訊（比如堆棧跟蹤資料）。

1.1.1Error🐧

public class Error

extends Throwable

Error 是 Throwable 的子類，用于訓示合理的應用程式不應該試圖捕獲的嚴重問題。大多數這樣的錯誤都是異常條件。雖然 ThreadDeath 錯誤是一個“正規”的條件，但它也是 Error 的子類，因為大多數應用程式都不應該試圖捕獲它。

在執行該方法期間，無需在其 throws 子句中聲明可能抛出但是未能捕獲的 Error 的任何子類，因為這些錯誤可能是再也不會發生的異常條件。

1.1.2Exception的層次🐯

public class Exception

extends Throwable

Exception 類及其子類是 Throwable 的一種形式，它指出了合理的應用程式想要捕獲的條件。

Exception 類是 Throwable 類的子類。除了Exception類外，Throwable還有一個子類Error 。

Java 程式通常不捕獲錯誤。錯誤一般發生在嚴重故障時，它們在Java程式處理的範疇之外

public class RuntimeException

extends Exception

RuntimeException 是那些可能在 Java 虛拟機正常運作期間抛出的異常的超類。

可能在執行方法期間抛出但未被捕獲的 RuntimeException 的任何子類都無需在 throws 子句中進行聲明。

索引越界，

1.2 JVM的預設處理方案🎉

如果程式出現了問題，我們沒有做任何處理，最終JVM會做預設的處理

把異常的名稱，異常原因及異常出現的位置等資訊輸出在控制台
程式停止執行

public class Abnormal {
    public static void main(String[] args) {
        System.out.println("開始");
        method();
        System.out.println("結束");
    }
    public static void method(){
        int arr [] = {1,2,3};
        System.out.println(arr[3]);
    }
}
/*
開始
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3 異常原因
    at com.ithmm_01.Abnormal.method(Abnormal.java:11)// 異常出現的位置
    at com.ithmm_01.Abnormal.main(Abnormal.java:6)

 */

1.3 異常處理🐷

1.4 異常處理之 try… catch…（捕獲異常）🦖

使用 try 和 catch 關鍵字可以捕獲異常。try/catch 代碼塊放在異常可能發生的地方。

try/catch代碼塊中的代碼稱為保護代碼，使用 try/catch 的文法如下：

格式

try
{
   // 可能出現異常的程式代碼
}catch(異常類名 變量名)
{
   //Catch 塊（異常的處理代碼）
}

Catch 語句包含要捕獲異常類型的聲明。當保護代碼塊中發生一個異常時，try 後面的 catch 塊就會被檢查。

如果發生的異常包含在 catch 塊中，異常會被傳遞到該 catch 塊，這和傳遞一個參數到方法是一樣。

執行流程：

程式從try裡面的代碼開始執行

出現異常，會自動生成一個異常類對象，該異常類對象将被送出給java運作時系統

當java運作時系統就收到異常對象時，會到catch中去找比對的異常類，找到後進行異常的處理

執行完成後，程式還可以繼續往下執行

代碼示例：

/*
try
{
   // 可能出現異常的程式代碼
}catch(異常類名 變量名)
{
   //Catch 塊（異常的處理代碼）
}
 */
public class TryCatch {
    public static void main(String[] args) {
        System.out.println("開始");
        method();
        System.out.println("結束");
    }
    public static void method(){
        try {
            int arr[] = {1, 2, 3};
            System.out.println(arr[3]);
        }catch(ArrayIndexOutOfBoundsException e){
            //System.out.println("數組下标越界");
            e.printStackTrance();
        }
    }
}

1.5 多重捕獲🐶

一個 try 代碼塊後面跟随多個 catch 代碼塊的情況就叫多重捕獲。

多重捕獲塊的文法如下所示：

try{
   // 程式代碼
}catch(異常類型1 異常的變量名1){
  // 程式代碼
}catch(異常類型2 異常的變量名2){
  // 程式代碼
}catch(異常類型3 異常的變量名3){
  // 程式代碼
}

上面的代碼段包含了 3 個 catch塊。

可以在 try 語句後面添加任意數量的 catch 塊。

如果保護代碼中發生異常，異常被抛給第一個 catch 塊。

如果抛出異常的資料類型與 ExceptionType1 比對，它在這裡就會被捕獲。

如果不比對，它會被傳遞給第二個 catch 塊。

如此，直到異常被捕獲或者通過所有的 catch 塊。

try {
    file = new FileInputStream(fileName);
    x = (byte) file.read();
} catch(FileNotFoundException f) { // Not valid!
    f.printStackTrace();
    return -1;
} catch(IOException i) {
    i.printStackTrace();
    return -1;
}

1.6 異常方法（Throwable的成員方法）🦜

下面的清單是 Throwable 類的主要方法:

方法名	說明
public String getMessage()	傳回關于發生的異常的詳細資訊。這個消息在Throwable 類的構造函數中初始化了。
public Throwable getCause()	傳回一個 Throwable 對象代表異常原因。
public String toString()	傳回此 Throwable 的簡短描述。
public void printStackTrace()	将此 Throwable 及其回溯列印到标準錯誤流。。
public StackTraceElement [] getStackTrace()	傳回一個包含堆棧層次的數組。下标為0的元素代表棧頂，最後一個元素代表方法調用堆棧的棧底。
public Throwable fillInStackTrace()	用目前的調用棧層次填充Throwable 對象棧層次，添加到棧層次任何先前資訊中。

1.7 編譯時異常和運作時異常的差別🐢

Java中的異常被分為兩大類：編譯時異常和運作時異常，也稱為受檢異常和非受檢異常

異常發生的原因有很多，通常包含以下幾大類：

使用者輸入了非法資料。
要打開的檔案不存在。
網絡通信時連接配接中斷，或者JVM記憶體溢出。

這些異常有的是因為使用者錯誤引起，有的是程式錯誤引起的，還有其它一些是因為實體錯誤引起的。-

要了解Java異常處理是如何工作的，你需要掌握以下三種類型的異常：

編譯時異常: 最具代表的檢查性異常是使用者錯誤或問題引起的異常，這是程式員無法預見的。例如要打開一個不存在檔案時，一個異常就發生了，這些異常在編譯時不能被簡單地忽略。

必須顯示處理，否則程式就會發生錯誤，無法通過編譯
運作時異常：運作時異常是可能被程式員避免的異常。與檢查性異常相反，運作時異常可以在編譯時被忽略。

無需顯示處理，也可以和編譯異常一樣處理
錯誤：錯誤不是異常，而是脫離程式員控制的問題。錯誤在代碼中通常被忽略。例如，當棧溢出時，一個錯誤就發生了，它們在編譯也檢查不到的。

運作時異常：

public static void main(String[] args) {
        method();
    }
    //運作時異常
    public static void method(){
        try {
            int arr[] = {1, 2, 3};
            System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
        }catch(ArrayIndexOutOfBoundsException e){
           e.printStackTrace();
        }
    }
}

public static void main(String[] args) {
        method1();
    }
    //編譯時異常
    public static void method1(){
        try {
            String s = "2022-06-20";
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date p = sdf.parse(s);
            System.out.println(p);
        }catch(ParseException e){
            e.printStackTrace();
        }

    }

1.8 異常處理之throws🐬

格式： throws   異常類名：

注意：這個格式是跟在方法的括号後面的

如果一個方法沒有捕獲到一個檢查性異常，那麼該方法必須使用 throws 關鍵字來聲明。throws 關鍵字放在方法簽名的尾部。

也可以使用 throw 關鍵字抛出一個異常，無論它是新執行個體化的還是剛捕獲到的。

下面方法的聲明抛出一個 RemoteException 異常：

import java.io.*;
public class className
{
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
}

一個方法可以聲明抛出多個異常，多個異常之間用逗号隔開。

例如，下面的方法聲明抛出 RemoteException 和 InsufficientFundsException：

import java.io.*;
public class className
{
   public void withdraw(double amount) throws RemoteException,
                              InsufficientFundsException
   {
       // Method implementation
   }
   //Remainder of class definition
}

總結：

編譯時異常必須進行處理，兩種處理方案：try …catch …或者throws，如果采用throws這種方案，将來誰調用處理誰（還是try…catch…）
運作時異常可以不處理，出問題後，需要我們回來修改代碼

1.9 聲明自定義異常🦀

在 Java 中你可以自定義異常。編寫自己的異常類時需要記住下面的幾點。

所有異常都必須是 Throwable 的子類。
如果希望寫一個檢查性異常類，則需要繼承 Exception 類。
如果你想寫一個運作時異常類，那麼需要繼承 RuntimeException 類。

格式：

public class 異常類名 extends Exception{

無參構造

帶參構造

}

隻繼承Exception 類來建立的異常類是檢查性異常類。

下面的 InsufficientFundsException 類是使用者定義的異常類，它繼承自 Exception。

一個異常類和其它任何類一樣，包含有變量和方法。

範例：

public class ScoreException extends Exception {
    public ScoreException() {
    }

    public ScoreException(String message) {
        super(message);
    }
}

代碼示例：

public class ScoreException extends Exception {
    public ScoreException() {
    }

    public ScoreException(String message) {
        super(message);
    }
}

public class Teacher {
    public  void checkScore(int score) throws ScoreException {
        if(score <0 ||score > 100){
            throw new ScoreException("分數異常，範圍0-100");
        }else{
            System.out.println("分數正常");
        }
    }
}

import java.util.Scanner;

public class TeacherDemo {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("請輸入學生成績： ");
       int score = s.nextInt();

       Teacher t = new Teacher();
       try {
           t.checkScore(score);
       }catch(ScoreException e ){
           e.printStackTrace();
       }
    }
}

2.0 throw和throws的差別🐣

throws	throw
用在方法聲明之後，跟的是異常類名	用在方法體内，跟的是異常對象名
表示抛出異常，由該方法的調用者來處理	表示抛出異常，由方法體内語句處理
表示出現異常的一種可能，并不一定會方法這種異常	執行throw一定抛出了某種異常

2.1 finally關鍵字🦋

finally 關鍵字用來建立在 try 代碼塊後面執行的代碼塊。

無論是否發生異常，finally 代碼塊中的代碼總會被執行。

在 finally 代碼塊中，可以運作清理類型等收尾善後性質的語句。

finally 代碼塊出現在 catch 代碼塊最後，文法如下：

try{
  // 程式代碼
}catch(異常類型1 異常的變量名1){
  // 程式代碼
}catch(異常類型2 異常的變量名2){
  // 程式代碼
}finally{
  // 程式代碼
}

代碼示例：

public class ExcepTest{
  public static void main(String args[]){
    int a[] = new int[2];
    try{
       System.out.println("Access element three :" + a[3]);
    }catch(ArrayIndexOutOfBoundsException e){
       System.out.println("Exception thrown  :" + e);
    }
    finally{
       a[0] = 6;
       System.out.println("First element value: " +a[0]);
       System.out.println("The finally statement is executed");
    }
  }
}

控制台輸出：

Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3

First element value: 6

The finally statement is executed

注意下面事項：

catch 不能獨立于 try 存在。
在 try/catch 後面添加 finally 塊并非強制性要求的。
try 代碼後不能既沒 catch 塊也沒 finally 塊。
try, catch, finally 塊之間不能添加任何代碼。

2.2 通用異常✨

在Java中定義了兩種類型的異常和錯誤。

JVM(Java虛拟機) 異常：由 JVM 抛出的異常或錯誤。例如：NullPointerException 類，ArrayIndexOutOfBoundsException 類，ClassCastException 類。

碼文異常不要怕，一篇文章精通應對【Java】中的異常

文章目錄

1. 異常💥

1.1 異常概述🎊

1.1.1Error🐧

1.1.2Exception的層次🐯

1.2 JVM的預設處理方案🎉

1.3 異常處理🐷

1.4 異常處理之 try… catch…（捕獲異常）🦖

1.5 多重捕獲🐶

1.6 異常方法（Throwable的成員方法）🦜

1.7 編譯時異常和運作時異常的差別🐢

1.8 異常處理之throws🐬

1.9 聲明自定義異常🦀

2.0 throw和throws的差別🐣

2.1 finally關鍵字🦋

2.2 通用異常✨

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method