【一步一步了解Java系列】:认识异常类

简介: 【一步一步了解Java系列】:认识异常类

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

加油陌生人 2.png

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


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

检查型异常/编译时异常(Checked Exceptions):

这些异常通常是由于编程错误导致的,比如FileNotFoundException或SQLException。

它们必须在方法签名中声明抛出,或者在方法内部被处理(通常是通过try-catch块)。

在运行前编译器就已经报出警告了:

  1. 非检查型异常/运行时异常(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。

  1. ** 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);

    }



}
  1. ** 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("捕捉到异常并解决异常的方法");
        }
    }
}


目录
相关文章
|
9天前
|
算法 Java 数据处理
从HashSet到TreeSet,Java集合框架中的Set接口及其实现类以其“不重复性”要求,彻底改变了处理唯一性数据的方式。
从HashSet到TreeSet,Java集合框架中的Set接口及其实现类以其“不重复性”要求,彻底改变了处理唯一性数据的方式。HashSet基于哈希表实现,提供高效的元素操作;TreeSet则通过红黑树实现元素的自然排序,适合需要有序访问的场景。本文通过示例代码详细介绍了两者的特性和应用场景。
29 6
|
1天前
|
Java 数据格式 索引
使用 Java 字节码工具检查类文件完整性的原理是什么
Java字节码工具通过解析和分析类文件的字节码,检查其结构和内容是否符合Java虚拟机规范,确保类文件的完整性和合法性,防止恶意代码或损坏的类文件影响程序运行。
|
1天前
|
Java API Maven
如何使用 Java 字节码工具检查类文件的完整性
本文介绍如何利用Java字节码工具来检测类文件的完整性和有效性,确保类文件未被篡改或损坏,适用于开发和维护阶段的代码质量控制。
|
5天前
|
Java
Java的原子变量类
Java的原子变量类
16 8
|
1天前
|
存储 Java 编译器
java wrapper是什么类
【10月更文挑战第16天】
7 3
|
2天前
|
存储 安全 Java
如何避免 Java 中的“ArrayStoreException”异常
在Java中,ArrayStoreException异常通常发生在尝试将不兼容的对象存储到泛型数组中时。为了避免这种异常,确保在操作数组时遵循以下几点:1. 使用泛型确保类型安全;2. 避免生类型(raw types)的使用;3. 在添加元素前进行类型检查。通过这些方法,可以有效防止 ArrayStoreException 的发生。
|
4天前
|
Java 程序员 测试技术
Java|让 JUnit4 测试类自动注入 logger 和被测 Service
本文介绍如何通过自定义 IDEA 的 JUnit4 Test Class 模板,实现生成测试类时自动注入 logger 和被测 Service。
16 5
|
3天前
|
人工智能 Oracle Java
解决 Java 打印日志吞异常堆栈的问题
前几天有同学找我查一个空指针问题,Java 打印日志时,异常堆栈信息被吞了,导致定位不到出问题的地方。
14 2
|
5天前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
10 3
|
7天前
|
存储 SQL 安全
Java零基础-StringBuilder类详解
【10月更文挑战第12天】Java零基础教学篇,手把手实践教学!
16 5