带你深入理解Java异常

简介: 带你深入理解Java异常

什么是异常

1.png

Java是一种面向对象编程语言,提供了一种强大的异常处理机制。Java异常是一个事件,它发生在程序执行过程中导致程序中断或出错。当发生异常时,Java程序会自动创建一个异常对象来表示该异常,并将异常对象传递给相应的异常处理程序来处理。

Java异常机制的主要目的是使程序更加可靠,因为在发生异常时,程序并不会异常终止,而是将异常传递给异常处理程序来处理。Java异常处理机制提供了一种强大的工具,使得程序能够处理错误情况,以便程序可以回复并继续执行。在Java中,异常可以分为两种类型:受查异常和非受查异常。


受查异常

受查异常也叫编译异常,是指在编译时必须显式地声明抛出该异常,否则编译器将会报错。受查异常通常是程序可以预料到并可能解决的异常,例如文件不存在、网络连接异常等。如果程序在编译时没有正确地处理受查异常,将会导致编译错误。

下面是一个示例代码,它使用了Java的IOException异常,这是一种受查异常。

import java.io.*;
public class FileHandling {
   public static void main(String args[]) {
      try {
         File file = new File("file.txt");
         FileReader fr = new FileReader(file);
         BufferedReader br = new BufferedReader(fr);
         String line;
         while((line = br.readLine()) != null) {
            System.out.println(line);
         }
         br.close();
      } catch(IOException e) {
         e.printStackTrace();
      }
   }
}

在上面的代码中,我们通过FileReader读取文件内容,并使用BufferedReader逐行读取文件内容。由于读取文件时可能会发生异常,我们需要在try-catch块中捕获并处理IOException异常。


非受查异常

非受查异常是指在编译时无须声明抛出该异常。通常情况下,非受查异常是由于程序中出现了错误,例如除数为零、数组下标越界等,并且发生这些异常时,程序无法自行恢复。因此,非受查异常通常会导致程序异常终止。


在Java中,非受查异常包括RuntimeException及其子类,例如NullPointerException(空指针异常)、ArrayIndexOutOfBoundsException(数组越界异常)、ArithmeticException(除数为0异常)等。这些异常通常是程序出现逻辑错误时才会产生。


下面是一个示例代码,它使用了Java的ArithmeticException异常,这是一种非受查异常。

public class Example {
   public static void main(String args[]) {
      int a = 10, b = 0;
      try {
         int c = a / b;
         System.out.println("Result: " + c);
      } catch(ArithmeticException e) {
         System.out.println("Exception caught: " + e);
      }
   }
}

在上面的代码中,我们尝试将10除以0,这会导致ArithmeticException异常的发生。由于程序无法自行恢复该异常,我们需要在try-catch块中捕获并处理该异常。


当出现异常的时候,我们必须自己手动处理这些异常,否则这些异常就会交给JVM处理,如果交给JVM处理,那么程序就会异常终止。

举个不恰当的例子,当你犯事的时候,如果只是你的父母发现知道了,那么你的父母可能会帮助你解决问题并且不告诉警察;但是如果你的父母不知道,但是被警察知道了,那么你就会被法律制裁。


怎样处理异常

事前防御型异常


Java中的事前防御型异常(Proactive Defense)指的是在代码开发阶段预先考虑和处理异常情况,以提高应用程序的健壮性和稳定性。事前防御型异常意味着通过将异常情况纳入代码设计和实现过程,尽可能主动地防止异常情况的发生,而不仅是在异常发生后采取响应措施。


意思也就是说:我根本不给你犯罪的机会,从你有这个萌芽的时候就扼杀你。

  public static int length(String s) {
        if(s == null) {
            return -1;
        }
        return s.length();
    }
    public static void main(String[] args) {
        System.out.println(length("abdias"));
    }

当我们用length来求字符串的长度时(有点多此一举了啊),你想要访问null的时候,我直接终止这个length,不让你访问null。这就是事前防御型异常。


事后认错型异常

Java中的事后认错型异常(Post-mortem Defense)是指在应用程序运行时发生异常时采取的响应措施。如果应用程序无法避免发生异常情况,那么事后认错型异常就是在程序发生异常后对异常进行收集和处理,以恢复应用程序的稳定性和可靠性。


Java中可以使用try-catch-finally块来捕获和处理发生的异常。try块中包含可能会引发异常的代码,catch块用于捕获处理异常情况,finally块用于确保代码块中的资源得到释放(即使异常发生)。

try {
  可能会出现异常的代码块
}catch(捕获的异常) {
  处理异常
}finally {
  确保代码块中的资源得到释放
}

我们今天主要讲的就是事后认错型异常。


异常的抛出

我们使用throw关键字来抛出一个指定的异常对象。

  public static int length(String s) {
        if(s == null) {
            throw new NullPointerException("字符串引用指向null");
        }
        return s.length();
    }
    public static void main(String[] args) {
        System.out.println(length(null));
    }

image.png


这里会将你出错的位置给你指出来,方便改正。


我们再来思考一个问题,就是如果这里抛出异常了,那么当出现异常的时候,其后面的代码还会执行吗?

public static int length(String s,int a) {
        if(s == null) {
            throw new NullPointerException("字符串引用指向null");
            a = 20;
        }
        return s.length();
    }
    public static void main(String[] args) {
        int a = 10;
        System.out.println(length(null,a));
        System.out.println(a);
    }

3.png

这里标红了,我们将鼠标放上去,可以看到提示,提示这个语句是不可能达到的,也就是说,当你s指向的不为null时,if语句根本就进不去,如果s指向的是null时,程序也不会走到a = 20这个语句,所以抛出异常的语句如果出现了异常,那么后面的语句将不会执行。


注意事项

1. throw必须写在方法体内部

2. 抛出的对象必须是Exception 或者 Exception 的子类对象

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

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

5. 异常一旦抛出,其后的代码就不会执行


异常的捕获

throws捕获异常

当你在方法参数的后面使用throws异常类型时,表明你这个方法可能会出现此类异常,但是在此方法中不处理异常,只是告诉你调用者会出现异常,具体怎样处理,需要你调用者处理。

  public static int length(String s) throws NullPointerException{
        if(s == null) {
            throw new NullPointerException("字符串引用指向null");
        }
        return s.length();
    }
    public static void main(String[] args) {
        int a = 10;
        System.out.println(length(null));
        System.out.println(a);
    }

就先这样,我length方法只是告诉你出现了空指针异常,但是空指针异常解决了吗?并没有,所以我们在方法参数后面使用throws 异常类型只是告诉调用者会出现那种类型的异常,具体解决需要调用者解决。如果你调用者没有解决异常,那么就需要继续用throws抛出异常。


注意事项

1. throws必须跟在方法的参数列表之后

2. 声明的异常必须是 Exception 或者 Exception 的子类

3. 方法内部如果抛出了多个异常,throws之后必须跟多个异常类型,之间用逗号隔开,如果抛出多个异常类型具有父子关系,直接声明父类即可。


如果我们想要解决这个异常该怎么办呢?


try-catch-finally捕获异常

try{
// 将可能出现异常的代码放在这里
}catch(要捕获的异常类型 e){
// 对异常就可以正常处理,处理完成后,跳出try-catch结构,继续执行后序代码
}catch(异常类型 e){
// 对异常进行处理
}finally{
// 此处代码一定会被执行到
}
// 后序代码
// 当异常被捕获到时,异常就被处理了,这里的后序代码一定会执行
// 如果捕获了,由于捕获时类型不对,那就没有捕获到,这里的代码就不会被执行

当try中的代码出现异常的时候,catch就会捕获try中出现的异常,并且对应的catch捕获的异常类型是与try中抛出的异常类型一致,或者是try中抛出异常的基类,当某个catch捕获到了对应的异常时,如果catch中的代码块执行完后,就会跳出其他的catch捕获到finally(如果有),否则就到后续的代码块,也就是说catch只能捕获到一种异常。

public static int length(String s) throws NullPointerException{
        if(s == null) {
            throw new NullPointerException("字符串引用指向null");
        }
        return s.length();
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = null;
        int ret = 0;
        try {
            ret = length(str);
        }catch(NullPointerException e) {
          //e.printStackTrace将栈上出现的异常给打印出来
            e.printStackTrace();
            System.out.println("传入的字符串为null,请重新输入");
            String tmp = scanner.nextLine();
            ret = length(tmp);
        }
        System.out.println(ret);
    }

4.png

注意事项

1. try块内抛出异常位置之后的代码将不会被执行

2. 如果抛出异常类型与catch时异常类型不匹配,即异常不会被成功捕获,也就不会被处理,继续往外抛,直到JVM收到后中断程序----异常是按照类型来捕获的。

3. try中可能会抛出多个不同的异常对象,则必须用多个catch来捕获----即多种异常,多次捕获。

4. 可以通过一个catch捕获所有的异常,即多个异常,一次捕获(不推荐)

catch (ArrayIndexOutOfBoundsException | NullPointerException e) { ... }

5.如果异常之间具有父子关系,一定是子类异常在前catch,父类异常在后catch,否则语法错误。


finally

finally中的代码是一定会被执行的,不管你的try中有没有出现异常,就算你在catch捕获异常并处理异常的时候return了,finally中的代码也是会出现在程序结束之前。

finally通常被用在网络连接数据库连接、IO流等,在程序正常或者异常退出时,必须要对资源进行回收。另外,因为异常会引发程序的跳转,可能导致有些语句执行不到,finally就是用来解决这个问题的。


自定义异常类

当我们平时登录账号的时候,如果用户名或者密码错误的时候,我们又该抛出怎样的异常呢?


Java中提供了非受查类异常NullPointerException(空指针异常)、IndexOutOfBoundsException(数组越界异常)、IllegalArguementException(无效参数异常)、ClassCastException(类型转换异常)等。这些在我们的日常生活中显然是不能完全覆盖到的,所以就出现了自定义异常,我们可以自己定义异常。


当我们自定义异常类的时候,我们需要继承Exception类或者Exception的子RunTimeException,建议继承RunTimeException。


自定义异常通常会继承自 Exception 或者 RuntimeException

继承自 Exception 的异常默认是受查异常

继承自 RuntimeException 的异常默认是非受查异常

public class Main {
    private static String name = "zhangsan";
    private static String ps = "123456";
    public static void login(String name,String ps) {
        if(!Main.name.equals(name)) {
            throw new NameException("用户名错误");
        }
        if(!Main.ps.equals(ps)) {
            throw new PasswordException("密码错误");
        }
    }
    public static void main1(String[] args) throws NameException,PasswordException{
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的用户名和密码");
        String name  = scanner.nextLine();
        String ps = scanner.nextLine();
        try {
            login(name,password);
        }catch(NameException e) {
            e.printStackTrace();
        }catch(PasswordException e) {
            e.printStackTrace();
        }
    }
class NameException extends RuntimeException {
    public NameException(String message) {
        super(message);
    }
}
class PasswordException extends RuntimeException {
    public PasswordException(String message) {
        super(message);
    }
}

5.png

6.png

相关文章
|
3月前
|
在 Java 中捕获和处理自定义异常的代码示例
本文提供了一个 Java 代码示例,展示了如何捕获和处理自定义异常。通过创建自定义异常类并使用 try-catch 语句,可以更灵活地处理程序中的错误情况。
112 1
如何避免 Java 中的 TimeoutException 异常
在Java中,`TimeoutException`通常发生在执行操作超过预设时间时。要避免此异常,可以优化代码逻辑,减少不必要的等待;合理设置超时时间,确保其足够完成正常操作;使用异步处理或线程池管理任务,提高程序响应性。
183 13
|
3月前
|
在 Java 中,如何自定义`NumberFormatException`异常
在Java中,自定义`NumberFormatException`异常可以通过继承`IllegalArgumentException`类并重写其构造方法来实现。自定义异常类可以添加额外的错误信息或行为,以便更精确地处理特定的数字格式转换错误。
64 1
Java社招面试题:一个线程运行时发生异常会怎样?
大家好,我是小米。今天分享一个经典的 Java 面试题:线程运行时发生异常,程序会怎样处理?此问题考察 Java 线程和异常处理机制的理解。线程发生异常,默认会导致线程终止,但可以通过 try-catch 捕获并处理,避免影响其他线程。未捕获的异常可通过 Thread.UncaughtExceptionHandler 处理。线程池中的异常会被自动处理,不影响任务执行。希望这篇文章能帮助你深入理解 Java 线程异常处理机制,为面试做好准备。如果你觉得有帮助,欢迎收藏、转发!
53 14
java语言后台管理若依框架-登录提示404-接口异常-系统接口404异常如何处理-登录验证码不显示prod-api/captchaImage 404 (Not Found) 如何处理-解决方案优雅草卓伊凡
java语言后台管理若依框架-登录提示404-接口异常-系统接口404异常如何处理-登录验证码不显示prod-api/captchaImage 404 (Not Found) 如何处理-解决方案优雅草卓伊凡
36 5
怎样避免 Java 中的 NoSuchFieldError 异常
在Java中避免NoSuchFieldError异常的关键在于确保类路径下没有不同版本的类文件冲突,避免反射时使用不存在的字段,以及确保所有依赖库版本兼容。编译和运行时使用的类版本应保持一致。
121 8
如何避免在 Java 中出现 NoSuchElementException 异常
在Java中,`NoSuchElementException`通常发生在使用迭代器、枚举或流等遍历集合时,尝试访问不存在的元素。为了避免该异常,可以在访问前检查是否有下一个元素(如使用`hasNext()`方法),或者使用`Optional`类处理可能为空的情况。正确管理集合边界和条件判断是关键。
134 6
|
3月前
|
Java异常捕捉处理和错误处理
Java异常捕捉处理和错误处理
90 1
Java异常处理的最佳实践,涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面
本文探讨了Java异常处理的最佳实践,涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面,帮助开发者提高代码质量和程序的健壮性。
112 2
|
3月前
|
如何在 Java 中处理“Broken Pipe”异常
在Java中处理“Broken Pipe”异常,通常发生在网络通信中,如Socket编程时。该异常表示写入操作的另一端已关闭连接。解决方法包括:检查网络连接、设置超时、使用try-catch捕获异常并进行重试或关闭资源。
177 5

热门文章

最新文章