看到这句话的时候证明：此刻你我都在努力

加油陌生人

个人主页：Gu Gu Study

专栏：一步一步了解Java

喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹

喜欢的话可以点个赞谢谢了。

作者：小闭

异常类的概念及其层次结构

Java中存在异常类，那么何为异常类呢？那么我们必须先了解一下它的概念：Java异常处理是Java语言中非常重要的一部分，它允许程序在遇到错误时能够优雅地处理问题而不是直接崩溃。Java异常类主要分为两大类：检查型异常（Checked Exceptions）和非检查型异常（Unchecked Exceptions）。

检查型异常/编译时异常（Checked Exceptions）：

这些异常通常是由于编程错误导致的，比如FileNotFoundException或SQLException。它们必须在方法签名中声明抛出，或者在方法内部被处理（通常是通过try-catch块）。在运行前编译器就已经报出警告了：

非检查型异常/运行时异常（Unchecked Exceptions）：

这些异常通常是由于运行时错误导致的，比如NullPointerException或ArithmeticException。它们不需要在方法签名中声明，也不强制要求必须被捕获处理。如图在运行前编译器是不会提示错误的：

Java中的异常就像我们生活中人生病一样，我们的程序也会生病，我们可以把计算机的病就叫做“异常”。

那么下面就给大家解析一下其层次结构：

Java异常类的层次结构从__java.lang__包中的__Throwable__类开始，它有两个主要的子类：Exception__和__Error。

Throwable：

Java异常类的根类。有两个重要的子类：Exception和Error。 Exception：

表示程序本身可以处理的异常情况。进一步分为IOException、SQLException等。 RuntimeException：

Exception的一个子类，表示在Java程序运行时发生的异常。包括NullPointerException、IndexOutOfBoundsException等。 Error：

表示JVM无法处理的错误，比如OutOfMemoryError或StackOverflowError。通常不需要程序去捕获这些错误

有关处理异常的关键词

在Java中处理异常我们有这么几个常用的关键词 ：throw、try、catch、finally、throws。

** throw 抛出异常 **

如下是一个简单的异常抛出，我们在一个方法中要执行一条语句时，如果其可能会发生异常，如：null，分母为0，数组访问越界，我们都可以自己抛出异常，如下为一个空指针异常

package demo1;

public class Test {

public static void testExceptinon(int[] arr){

if(arr==null){

throw new ArithmeticException();

}

}

public static void main(String[] args) {

int[] arr=null;

testExceptinon(arr);

}

}

所谓抛出异常其实就是抛出一个Exception或Exception的子类。

注意事项：

抛出异常类其必须是Exception或Exception的子类。

抛出异常必须在方法内部

如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理

** 如果抛出的是编译时异常，用户必须处理，否则无法通过编译**

** 异常一旦抛出，其后的代码就不会执**

异常声明throws

throws一个用来声明异常的关键词，是用在方法上的，具体格式为

** 修饰符 返回值类型 方法名(参数列表) throws 异常类型1，异常类型2…{ } **

注意throws只是起到警示作用，就是给程序员知道用这个方法可能会抛出异常。不会解决异常。

public class Test {

public static final void test1 ()throws RuntimeException{

int a=10;

int c=0;

System.out.println(a/c);

}

}

** try-catch捕获并处理 **

解决异常还得用到try-catch语句，这是我们常用处理异常的关键词，当然还有finally关键词，稍后我也会提到。

import com.sun.security.jgss.GSSUtil;

public class Test {

public static final void test1 ()throws ArithmeticException{

int a=10;

int c=0;

System.out.println(a/c);

}

public static void main(String[] args) {

int q=10;

int p=100;

String s="hello world";

System.out.println(q+p);

try{

test1(); //try的花括号内是放入可能会抛出异常的语句

//如果里面的语句没有抛出异常则会跳出try-catch语句

}catch (ArithmeticException e){ //小括号里是放入可能会捕捉到的异常类 e

System.out.println("处理异常"); //catch花括号内是我们自行处理异常的方法

}finally {

System.out.println("无论是否捕捉到异常都一定会执行的代码"); //finally里的语句无论是否检测到异常都会执行的语句

}

System.out.println("处理完异常后的代码执行"); //这是处理异常后才会执行的语句

// 当异常被捕获到时，异常就被处理了，这里的后序代码一定会执行

//如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行

}

}

try的花括号内是放入可能会抛出异常的语句， 如果里面的语句没有抛出异常则会跳出try-catch语句catch的小括号里是放入可能会捕捉到的异常类 e，catch花括号内是我们自行处理异常的方法catch-catch-finally外的语句：当异常被捕获到时，异常就被处理了，这里的后序代码一定会执行，如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行

** finally **

配合try-catch语句用的，但是其不是一定要加上去的，而try-catch一定是一起出现的。

在写程序时，有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库 连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。另外，因为异常会引发程序的跳转，可能 导致有些语句执行不到，finally就是用来解决这个问题的。

public static int getData() {

Scanner sc = null;

try {

sc = new Scanner(System.in);

int data = sc.nextInt();

return data;

} catch (InputMismatchException e) {

e.printStackTrace();

} finally {

System.out.println("finally中代码");

}

System.out.println("try-catch-finally之后代码");

if (null != sc) {

sc.close();

}

return 0;

}

public static void main(String[] args) {

int data = getData();

System.out.println(data);

}

上述程序，如果正常输入，成功接收输入后程序就返回了，try-catch-finally之后的代码根本就没有执行，即输入流 就没有被释放，造成资源泄漏。

自定义异常类

使用的较多的异常类往往是我们自己定义的比较多，那么如何自定义异常类呢，下面我们就来讲讲如何自定义异常类。

class textException extends RuntimeException{

public textException() {

}

public textException(String message) {

super(message);

}

}

public class Test1 {

public static void main(String[] args) {

int a=0;

if(a==0){

throw new textException();

}

}

}

如上我们只需让自己创建出的类继承Exception或其它异常类即可，这样这个类也是一个异常类了。

然后我们在需要抛出异常时，抛出自己定义的异常即可。

也可以用try-catch进行使用解决自己定义的异常。

注意事项：

** 自定义异常通常会继承自 Exception 或者 RuntimeException ****继承自 Exception 的异常默认是受查异常 ****继承自 RuntimeException 的异常默认是非受查异常 **

异常的处理流程

关于 “调用栈” 方法之间是存在相互调用关系的, 这种调用关系我们可以用 “调用栈” 来描述. 在 JVM 中有一块内存空间称为 “虚拟机栈” 专门存储方法之间的调用关系. 当代码中出现异常的时候, 我们就可以使用 e.printStackTrace(); 的 方式查看出现异常代码的调用栈. 如果本方法中没有合适的处理异常的方式, **就会沿着调用栈向上传递 **

public class Test {

public static final void func1(){

int[] a={1,2,3,4,5};

a[10] = 100;

}

public static void main(String[] args) {

try {

func1();

System.out.println("hello world");

}catch (ArrayIndexOutOfBoundsException e){

e.printStackTrace();

System.out.println("没能合适解决异常");

}

}

}

如上图：在func1中如果没进行处理，堆栈就会延栈调用，也就是图中又看mian方法中是否能够处理好异常，一直向上传递如果都无法解决，一旦交给JVM处理那么程序将会终止，就不会进行之后的代码。

异常类与if的区别

首先我们来说说if在应对程序的应用是怎样的？

if语句：

比如：下面代码我们的if就是在检测到b==0时,就不让程序继续进行下面的计算。

这属于一种事先防卫型，就是避免错误发生。在发生之前就将程序阻断。

package demo1;

import java.util.Scanner;

public class Test {

public static void main(String[] args) {

Scanner sc=new Scanner(System.in);

int a=sc.nextInt();

int b=sc.nextInt();

if(b==0){

System.out.println("分母为0，数字不合法");

}else {

System.out.println("a/c= "+a/b);

}

}

}

异常类：

如下：异常类相比于if更像是先斩后奏型，事后处理型，在程序发现问题时在进行处理问题，如下代码将可能有异常的语句放到try括号中，如果出现异常在进行解决：

package demo1;

public class Test1 {

public static void main(String[] args) {

int a=10;

int b=0;

try{

System.out.println("a/c= "+a/b);

}catch (ArithmeticException e){

System.out.println("捕捉到异常并解决异常的方法");

}

}

}