超详细的Java异常处理机制知识整理2

简介: 超详细的Java异常处理机制知识整理2
try+catch+finally:
try{
//可能抛出异常的代码
}
catch(异常类型 异常对象名){
//针对异常的处理代码
}finally{
无论异常是否发生,都无条件执行的代码
}

举例:

public class a {
    public static void main(String[]args) {
        int []arr=new int[5];
        int i;
        try{
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
        }
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
        finally{
            System.out.println("我是finally代码段");
        }
        System.out.println("程序结束!");
    }
}


输出:

0
0
0
0
0
我是finally代码段
程序结束!
java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
  at Employee.a.main(a.java:9)


这种组合输出,当发生异常由catch捕获处理完异常之后,继续执行下面未执行完的语句。

注意!!!

1:finally代码段与其上面的catch代码段之间不能再添加其他代码语句。

2:try,finally这种形式由于没有对异常进行任何的处理,所以一般不会应用在实际开发中。


throws和throw关键字的使用:

throws关键字的使用:

如果当前方法不对异常进行处理,可以通过声明抛出异常,将处理该异常的任务交给当前方法的调用者,throws用在方法声明部分的结尾处,表示该方法抛出异常,一个方法可以声明抛出多个异常,这取决于方法中可能产生的异常个数,如果抛出多个异常,那么这些多个异常之间用逗号隔开,一个声明了抛出异常的方法定义格式如下:

[修饰符] 返回值类型 方法名([参数列表])[throws 异常列表]{
   //  方法体;
}      
public class a {
    public static void print() throws ArrayIndexOutOfBoundsException{
        int []arr=new int[5];
        int i;
//print()方法体并没有使用try-catch对ArrayIndexOutOfBoundsException异常进行处理,而是通过throws关键字声明抛出
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
    }
    public static void main(String[]args)throws ArrayIndexOutOfBoundsException{
    //main()方法中对print()方法进行了调用,通过try-catch方式对print()方法抛出的异常进行捕获处理。
        try{
            print();
        }
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
    }
}

输出:

0
0
0
0
0
java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
  at Employee.a.print(a.java:9)
  at Employee.a.main(a.java:13)


当然main方法也可以不用try-catch方式处理,而是继续通过trows关键字抛出。


那么运行结果通过运行结果,我们能够了解什么信息呢?


首先通过输出信息的最上部(异常入栈时位于栈底)入手去源文件中查找异常产生的原因。那么在本例中,我们通at Employee.a.print(a.java:9),应该去第九行寻找原因!


注意!!!


如果一个方法通过trows声明抛出了异常,那么调用该方法的其他方法可以通过try-catch方式进行捕获处理,也可以继续通过throws声明将异常抛出。


一般不建议在main方法中通过trows声明抛出异常原因为:Java中发生异常如果一直上抛,最终抛给了main方法,main方法继续上抛,抛给了调用者JVM,JVM终止程序的执行。


这样看来好像也没什么错,但是异常处理机制的作用就是提高程序的健壮性,保证程序出现了异常也能执行,所以main方法中的异常建议是使用try-catch进行捕捉,而不是继续上抛!


throw关键字的使用:

throw关键字主要用在方法体中对异常进行抛出,通常方法体中捕获到相关异常对象后并不进行处理,将对象的处理交给当前方法的调用者,一个通过throw关键字声明抛出异常的方法定义格式如下:

[修饰符] 返回值类型 方法名([参数列表])[throws 异常列表]{
   //  方法体;
   throw异常对象;
}  


举例:

public class a { 
    public static void print(){
        int []arr=new int[5];
        int i;
        try{
            for( i=0;i<=arr.length;i++)
                System.out.println(arr[i]);
        }
        //该catch并没有对异常进行处理,而是通过trow将异常对象抛出了
        catch(ArrayIndexOutOfBoundsException e){
            throw e;
        }
    }
    public static void main(String[]args){
        try{
            print();
        }
        //main方法中的catch捕获到try中调用print方法的异常并对其进行处理
        catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
    }
}

输出:

0
0
0
0
0
java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
  at Employee.a.print(a.java:8)
  at Employee.a.main(a.java:16)


提醒:

由于这里的ArrayIndexOutOfBoundsException是运行时异常,所以print()方法声明部分的结尾不再需要throws,如果throw抛出的是某个非运行异常,那么throw所在的方法的声明尾部还需要通过throws声明将这个非运行时异常对象抛出。


自定义异常:

在实际开发中,异常正所谓是“千姿百态”,但JDK提供给我们的异常类型是很有限的,因此面对实际开发中的各种异常问题,我们除了灵活使用JDK提供给我们的之外,还需要我们自定义一些异常,这些异常也就是我们在面向对象编程的过程中,出现的特有问题。


既然是自定义,那么由于每个人想法和处理问题的方式不同,很容易出现操作异常等问题,为了解决这种问题,我们规定自定义异常必须继承Exception或者RuntimeException,从Exception继承表示自定义异常是非运行时异常,从RuntimeException继承表示自定义异常是运行时异常,当腰操作自定义异常的信息时,可以使用父类已经定义好的方法


定义异常的一般形式如下:

class 异常类名 extends Exception|RunException
{
//类体
}

举例:

当输入的分数小于0时,捕获异常并输出分数不能小于0的提示信息。

主类:

package exception;
import java.util.Scanner;
public class exception {
   public static  void show_score() throws Text {
   //该方法并没有对分数小于0的这种情况进行任何的处理,而是创建异常对象将它抛出
       int score;
       Scanner scanner=new Scanner(System.in);
       score=scanner.nextInt();
       if(score<0){
           throw new Text("分数不能小于0");
       }
   }
    public static void main(String[]args){
    //在main方法中捕获到该异常,并对其进行处理
        try{
            show_score();
        } catch (Text e) {
            e.printStackTrace();
        }
    }
}

由于JDK并没有为我们提供某一个异常来描述分数不能小于0的这种情况,所以需要自定义异常类[这里的异常类为Text类]来表示分数不能小于0的这种情况,且该异常是非运行异常,因此需要继承Exception类。

自定义异常类:

package exception;
public class Text extends Exception{
    public Text(String message) {
        super(message);
    }
}

输出:

注意:如果该异常属于RuntimeException,那么在方法的尾部不需要throws声明将该异常抛出,反之如果是Exception,则需要声明抛出

异常处理事项:

如果一个方法产生的异常不止一种,且这些异常具有父子关系,那么书写catch代码块时,处理异常的catch块要位于处理子异常catch块的后面。

依然是上述事例:

  public static void main(String[]args){
        try{
            show_score();
        }
        catch (Text e) {
            e.printStackTrace();
        }
        catch(Exception e){
            e.printStackTrace();
        }

由于Text异常类继承了Exception类,所以处理父类Exception类的catch代码块必须写在子类Text的后面。

在进行方法覆盖时,如果被覆盖的方法抛出异常,那么覆盖方法可以不抛异常,或者抛与被覆盖方法相同的异常,或者抛被覆盖方法的所抛异常的子异常。


定义父类抛出Exception类异常:

package exception;
public class Father {
    public void show() throws Exception{
        int a=10;
       if(a<100){
           throw new Exception();
       }
        System.out.println("hello,Java");
    }
}

子类对象对父类中的show方法进行覆盖:

package exception;
public class Son extends Father{
  @Override
    public void show() throws Exception {
        System.out.println("helloJava");//抛出和父类相同的异常
    }
  @Override
    public void show() throws Text{//抛出父类抛出的异常的子异常类
        System.out.println("helloJava");
    }
      @Override
    public void show() {//未抛出异常
        System.out.println("helloJava");
    }
}

以上三种方式均正确!

如果try代码中有return语句返回基本数据类型变量,即使finally中对该基本数据类型变量进行修改,返回结果以try中修改的值为准。

举例:

package exception;
import java.util.Scanner;
public class exception {
   private static int getnumber(){
       int i=0;
       try{
           i=100;
           return i;
       }catch (Exception e){
           e.printStackTrace();
       }finally//在finally中改变基本数据类型变量i的值
           i=1000;
       }
       return i;
    }
    public static void main(String[]args){
        System.out.println(getnumber());
    }
}

输出:

100//try中的值

如果try代码中有return语句,返回引用数据类型变量,finally中对该引用数据类型变量进行修改,返回结果以finally中修改的值为准。

举例:

package exception;
import java.util.Scanner;
public class exception {
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
private static exception getname(){
        exception exception=new exception();
        try{
            exception.setName("张三");
            return exception;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            exception.setName("小张");
        }return exception;
}
        public static void main(String[]args){
            System.out.println(getname().getName());
        }
}

输出:

李四//finally中的值

如果try,finally代码中都有return语句,无论返回什么数据类型,返回结果以finally中修改的值为准。

举例:

package exception;
import java.util.Scanner;
public class exception {
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
private static exception getname(){
//try和finally语句中都含有return语句
        exception exception=new exception();
        try{
            exception.setName("张三");
            return exception;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            exception.setName("小张");
            return exception;
        }
}
        public static void main(String[]args){
            System.out.println(getname().getName());
        }
}

输出:

小张//finally中的值
相关文章
|
3天前
|
监控 Java 应用服务中间件
高级java面试---spring.factories文件的解析源码API机制
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置、起步依赖和内嵌服务器等特性,极大地简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理,并通过Java代码手写模拟Spring Boot的启动过程,特别是spring.factories文件的解析源码API机制。
16 2
|
8天前
|
Java 编译器
探索Java中的异常处理机制
【10月更文挑战第35天】在Java的世界中,异常是程序运行过程中不可避免的一部分。本文将通过通俗易懂的语言和生动的比喻,带你了解Java中的异常处理机制,包括异常的类型、如何捕获和处理异常,以及如何在代码中有效地利用异常处理来提升程序的健壮性。让我们一起走进Java的异常世界,学习如何优雅地面对和解决问题吧!
|
8天前
|
Java 开发者
Java中的异常处理:从基础到高级
【10月更文挑战第35天】在Java的世界里,异常处理是维护程序健壮性的关键。本文将深入浅出地探讨Java的异常处理机制,从基本的try-catch语句到自定义异常类的实现,带领读者理解并掌握如何在Java中优雅地处理错误和异常。我们将通过实际代码示例,展示如何捕获、处理以及预防潜在的运行时错误,确保程序即使在面临意外情况时也能保持稳定运行。
24 7
|
8天前
|
Java 编译器 数据库连接
Java中的异常处理机制深度解析####
本文深入探讨了Java编程语言中异常处理机制的核心原理、类型及其最佳实践,旨在帮助开发者更好地理解和应用这一关键特性。通过实例分析,揭示了try-catch-finally结构的重要性,以及如何利用自定义异常提升代码的健壮性和可读性。文章还讨论了异常处理在大型项目中的最佳实践,为提高软件质量提供指导。 ####
|
7天前
|
Java 数据库连接 开发者
Java中的异常处理机制及其最佳实践####
在本文中,我们将探讨Java编程语言中的异常处理机制。通过深入分析try-catch语句、throws关键字以及自定义异常的创建与使用,我们旨在揭示如何有效地管理和响应程序运行中的错误和异常情况。此外,本文还将讨论一些最佳实践,以帮助开发者编写更加健壮和易于维护的代码。 ####
|
11天前
|
Java
Java 异常处理下篇:11 个异常处理最佳实践
本文深入探讨了 Java 异常处理的最佳实践,包括早抛出晚捕获、只捕获可处理的异常、不要忽略捕获的异常、抛出具体检查性异常、正确包装自定义异常、记录或抛出异常但不同时执行、避免在 `finally` 块中抛出异常、避免使用异常进行流程控制、使用模板方法处理重复的 `try-catch`、尽量只抛出与方法相关的异常以及异常处理后清理资源。通过遵循这些实践,可以提高代码的健壮性和可维护性。
|
11天前
|
Java 编译器 开发者
Java异常处理的最佳实践,涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面
本文探讨了Java异常处理的最佳实践,涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面,帮助开发者提高代码质量和程序的健壮性。
27 2
|
13天前
|
Java 程序员 数据库连接
深入浅出Java异常处理
【10月更文挑战第30天】在Java的世界里,异常处理就像是生活中的急救箱,遇到意外时能及时救治。本文不仅教你如何使用try-catch语句包扎“伤口”,还会深入讲解如何通过自定义异常来应对那些常见的“头疼脑热”。准备好,我们将一起探索Java异常处理的奥秘,让你的程序更加健壮。
|
13天前
|
安全 IDE Java
Java反射Reflect机制详解
Java反射(Reflection)机制是Java语言的重要特性之一,允许程序在运行时动态地获取类的信息,并对类进行操作,如创建实例、调用方法、访问字段等。反射机制极大地提高了Java程序的灵活性和动态性,但也带来了性能和安全方面的挑战。本文将详细介绍Java反射机制的基本概念、常用操作、应用场景以及其优缺点。 ## 基本概念 ### 什么是反射 反射是一种在程序运行时动态获取类的信息,并对类进行操作的机制。通过反射,程序可以在运行时获得类的字段、方法、构造函数等信息,并可以动态调用方法、创建实例和访问字段。 ### 反射的核心类 Java反射机制主要由以下几个类和接口组成,这些类
31 2
|
14天前
|
Java 程序员 数据库连接
Java中的异常处理:理解与实践
【10月更文挑战第29天】在Java编程的世界里,异常像是不请自来的客人,它们可能在任何时候闯入我们的程序宴会。了解如何妥善处理这些意外访客,不仅能够保持我们程序的优雅和稳健,还能确保它不会因为一个小小的失误而全盘崩溃。本文将通过浅显易懂的方式,带领读者深入异常处理的核心概念,并通过实际示例展现如何在Java代码中实现有效的异常管理策略。