码文异常不要怕，一篇文章精通应对【Java】中的异常
异常：就是程序出现了不正常的情况
异常体系：
Error：严重问题，不需要处理。
Exception：称为异常类，他表示程序本身可以处理的问题。
- RuntimeException:在编译期是不检查的，出问题后，需要我们回来修改代码。
- 非RuntimeException：编译期间就必须处理，否则程序不能通过编译，就更不能正常运行
异常：索引越界
所有的异常类是从 java.lang.Exception 类继承的子类。
-
public class Throwable
-
extends Object
-
implements Serializable
Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。
两个子类的实例，Error 和 Exception，通常用于指示发生了异常情况。通常，这些实例是在异常情况的上下文中新近创建的，因此包含了相关的信息（比如堆栈跟踪数据）。
public class Error
extends Throwable
Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。大多数这样的错误都是异常条件。虽然 ThreadDeath 错误是一个“正规”的条件，但它也是 Error 的子类，因为大多数应用程序都不应该试图捕获它。
在执行该方法期间，无需在其 throws 子句中声明可能抛出但是未能捕获的 Error 的任何子类，因为这些错误可能是再也不会发生的异常条件。
public class Exception
extends Throwable
Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。
Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。
Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外
public class RuntimeException
extends Exception
RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。
可能在执行方法期间抛出但未被捕获的 RuntimeException 的任何子类都无需在 throws 子句中进行声明。
索引越界，
如果程序出现了问题，我们没有做任何处理，最终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) */
使用 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(); } } }
一个 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; }
下面的列表是 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 对象栈层次，添加到栈层次任何先前信息中。 |
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(); } }
-
格式： 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…）
- 运行时异常可以不处理，出问题后，需要我们回来修改代码
在 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(); } } }
| throws | throw |
|---|---|
| 用在方法声明之后，跟的是异常类名 | 用在方法体内，跟的是异常对象名 |
| 表示抛出异常，由该方法的调用者来处理 | 表示抛出异常，由方法体内语句处理 |
| 表示出现异常的一种可能，并不一定会方法这种异常 | 执行throw一定抛出了某种异常 |
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 块之间不能添加任何代码。
在Java中定义了两种类型的异常和错误。
JVM(Java虚拟机) 异常： 由 JVM 抛出的异常或错误。例如：NullPointerException 类，ArrayIndexOutOfBoundsException 类，ClassCastException 类。
程序级异常： 由程序或者API程序抛出的异常。例如 IllegalArgumentException 类，IllegalStateException 类。
