Java 异常处理以及如何捕获和处理多个异常-Toy模板网

这篇具有很好参考价值的文章主要介绍了Java 异常处理以及如何捕获和处理多个异常。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

捕捉和处理异常

在Java中，我们使用异常处理程序组件try，catch和finally块来处理异常。

为了捕获和处理异常，我们将try...catch...finally代码块放置在可能产生异常的代码周围。finally块是可选的。

try...catch...finally的语法为：

try {
  // 代码
} catch (ExceptionType e) { 
  // 捕获块
} finally {
  //finally块
}

Java try ... catch块

可能会生成异常的代码放在try块中。

每个try块后面应紧跟着catch 或 finally块。发生异常时，它会被catch紧随其后的块捕获。

catch块不能单独使用，必须紧随try块。

示例1：try ... catch块

class Main {
  public static void main(String[] args) {

    try {
      int divideByZero = 5 / 0;
      System.out.println("try块中的其余代码");
    } catch (ArithmeticException e) {
      System.out.println("ArithmeticException => " + e.getMessage());
    }

  }
}

输出结果

ArithmeticException => / by zero

在这个实例中

我们在try块中将数字除以0。这产生一个ArithmeticException。

发生异常时，程序将跳过try块中的其余代码。

在这里，我们创建了一个catch块来处理ArithmeticException。因此，将catch执行块内的语句。

如果该try块中的所有语句均未生成异常，则跳过catch代码块。

多个捕获块

对于每个try块，可以有零个或多个catch块。

每个catch块的参数类型指示可以处理的异常类型。多个catch块使我们能够以不同方式处理每个异常。

示例2：多个捕获块

class ListOfNumbers {
  public int[] arrayOfNumbers = new int[10];

  public void writeList() {

    try {
      arrayOfNumbers[10] = 11;
    } catch (NumberFormatException e1) {
      System.out.println("NumberFormatException => " + e1.getMessage());
    } catch (IndexOutOfBoundsException e2) {
      System.out.println("IndexOutOfBoundsException => " + e2.getMessage());
    }

  }
}

class Main {
  public static void main(String[] args) {
    ListOfNumbers list = new ListOfNumbers();
    list.writeList();
  }
}

输出结果

IndexOutOfBoundsException => Index 10 out of bounds for length 10

在此示例中，我们声明了一个大小为10 的整数数组arrayOfNumbers。

我们知道数组索引总是从0开始。因此，当我们尝试为索引10分配一个值时，就会发生IndexOutOfBoundsException，因为数组arrayOfNumbers的边界是0到9。

当try块中发生异常时：

异常被抛出给第一个catch块。第一个catch块不处理IndexOutOfBoundsException异常，因此它被传递给下一个catch块。

上面示例中的第二个catch块是适当的异常处理程序，因为它处理IndexOutOfBoundsException。因此，它被执行。

Java Finally块

对于每个try块，只能有一个finally块。

finally块是可选的。但是，如果已定义，它将始终执行（即使不会发生异常）。

如果发生异常，则在try...catch块之后执行。如果没有异常发生，则在try块之后执行。

finally块的基本语法为：

try {
  //code
} catch (ExceptionType1 e1) { 
  // catch 块
} catch (ExceptionType1 e2) {
 // catch 块
} finally {
  //finally块一直执行
}

示例3：finally块示例

class Main {
  public static void main(String[] args) {
    try {
      int divideByZero = 5 / 0;
    } catch (ArithmeticException e) {
      System.out.println("ArithmeticException => " + e.getMessage());
    } finally {
      System.out.println("Finally块总是执行");
    }
  }
}

输出结果

ArithmeticException => / by zero
Finally块总是执行

在此示例中，我们将数字除以0。这引发了一个ArithmeticException被catch块捕获，finally块始终执行。

使用finally块被认为是一种很好的做法。这是因为它包含了重要的清理代码，例如

可能被return、continue或break语句意外跳过的代码

关闭文件或连接

我们已经提到，finally总是执行，通常是这样的。但是，在某些情况下，finally块不执行：

使用 System.exit()方法

finally块中发生异常

线程被终止

示例4：try, catch 和finally示例

让我们举一个实例，我们尝试使用FileWriter创建一个新文件，并使用PrintWriter写入数据。

import java.io.*;

class ListOfNumbers {
  private int[] list = new int[10];

  public ListOfNumbers() {
    //在列表数组中存储整数值
    for (int i = 0; i < 10; i++) {
      list[i] = i;
    } 	
  }

}

  public void writeList() {
    PrintWriter out = null;

    try {
      System.out.println("进入try语句");

      //创建一个新文件OutputFile.txt
      out = new PrintWriter(new FileWriter("OutputFile.txt"));

      //将值从列表数组写入新创建的文件
      for (int i = 0; i < 10; i++) {
        out.println("Value at: " + i + " = " + list[i]);
      }
    } catch (IndexOutOfBoundsException e1) {
      System.out.println("IndexOutOfBoundsException => " + e1.getMessage());
    } catch (IOException e2) {
      System.out.println("IOException => " + e2.getMessage());
    } finally {
      //检查PrintWriter是否被打开
      if (out != null) {
        System.out.println("关闭PrintWriter");
        out.close();
      } else {
        System.out.println("PrintWriter无法打开");
      }
    }

  }
}

class Main {
  public static void main(String[] args) {
    ListOfNumbers list = new ListOfNumbers();
    list.writeList();
  }
}

当您运行此程序时，可能会发生两种可能性：

try块中发生异常
try块正常执行

创建新的FileWriter时可能会发生异常。如果无法创建或写入指定的文件，则抛出IOException。

当发生异常时，我们将获得以下输出。

进入try语句
IOException => OutputFile.txt
PrintWriter无法打开

当未发生异常且该try块正常执行时，我们将获得以下输出。

进入try语句
关闭PrintWriter

将创建一个OutputFile.txt，并包含以下内容

Value at: 0 = 0
Value at: 1 = 1
Value at: 2 = 2
Value at: 3 = 3
Value at: 4 = 4
Value at: 5 = 5
Value at: 6 = 6
Value at: 7 = 7
Value at: 8 = 8
Value at: 9 = 9

try ... catch...finally 详细流程

让我们尝试在上述示例的帮助下详细了解异常处理的流程。

Java 异常处理以及如何捕获和处理多个异常,Java异常处理,java,开发语言,算法

上图描述了在创建新FileWriter时发生异常时的程序执行流程。

为了找到发生异常的方法，主方法调用writeList()方法，该方法随后调用FileWriter()方法来创建一个新的OutputFile.txt文件。

发生异常时，运行时系统将跳过try块中的其余代码。

它开始以相反的顺序搜索调用堆栈，以找到合适的异常处理程序。

这里，FileWriter没有异常处理程序，因此运行时系统检查调用堆栈中的下一个方法，即writeList。

writeList方法有两个异常处理程序：一个处理IndexOutOfBoundsException，另一个处理IOException。

然后，系统依次处理这些处理程序。

此示例中的第一个处理程序处理IndexOutOfBoundsException。这与try块引发的IOException不匹配。

因此，检查下一个处理程序是哪个IOException处理程序。如与引发的异常类型匹配，因此将执行对应catch块中的代码。

执行异常处理程序后，将执行finally块。

在此场景中，由于FileWriter中发生了异常，所以PrintWriter对象out从未打开，因此不需要关闭。

现在，让我们假设在运行该程序时没有发生异常，并且try块正常执行。在这种情况下，将创建并写入一个OutputFile.txt。

众所周知，finally块的执行与异常处理无关。由于没有异常发生，因此PrintWriter打开了并且需要关闭。这是通过finally块中的out.close()语句完成的。

捕获和处理多个异常

在Java 7之前，即使存在代码冗余，我们也必须针对不同类型的异常编写多个异常处理代码。

示例1：多个捕获块

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException e) {
      System.out.println(e.getMessage());
    } catch (ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    } 
  }
}

输出结果

/ by zero

在此的示例可能会发生两个异常：

ArithmeticException - 因为我们试图将数字除以0。

ArrayIndexOutOfBoundsException - 因为我们已经声明了一个新的整数数组，数组边界为0到9，并且我们试图为索引10分配一个值。

我们在两个catch块中都打印出异常消息，即重复代码。

赋值运算符（=）的关联性是从右到左，因此首先将ArithmeticException与消息 / by zero起抛出。

在catch块中处理多个异常

现在可以在单个catch块中捕获多种类型的异常。

可以由catch块处理的每种异常类型都使用竖线（|）分隔。

其语法为：

try {
  // code
} catch (ExceptionType1 | Exceptiontype2 ex) { 
  // catch block
}

示例2：单个catch块中捕获多个异常

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    }
  }
}

输出结果

/ by zero

在单个catch块中捕获多个异常，可以减少代码重复并提高效率。

编译该程序时生成的字节码将比具有多个catch块的程序小，因为没有代码冗余。

注意：如果一个catch块处理多个异常，则catch参数为隐式final。这意味着我们不能分配任何值来捕获参数。

捕获基本异常

当在单个catch块中捕获多个异常时，该规则将泛化为专门化规则。

这意味着，如果catch块中存在异常的层次结构，我们只能捕获基本异常，而不能捕获多个专门的异常。

让我们举个实例。

示例3：仅捕获基本异常类

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
  }
}

输出结果

/ by zero

我们知道所有异常类都是Exception类的子类。因此，我们不必捕获多个专门的异常，而只需捕获Exception类。

如果已经在catch块中指定了基本异常类，则不要在同catch一块中使用子异常类。否则，我们会得到一个编译错误。

让我们举个实例。

示例4：捕获基类和子异常类

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (Exception | ArithmeticException | ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    }
  }
}

输出结果

Main.java:6: error: Alternatives in a multi-catch statement cannot be related by subclassing

在此示例中，ArithmeticException和ArrayIndexOutOfBoundsException都是Exception类的子类。因此，我们抛出一个编译错误。文章来源地址https://www.toymoban.com/news/detail-622026.html

到了这里，关于Java 异常处理以及如何捕获和处理多个异常的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

Java 异常处理以及如何捕获和处理多个异常

捕捉和处理异常

Java try ... catch块

示例1：try ... catch块

多个捕获块

示例2：多个捕获块

Java Finally块

示例3：finally块示例

示例4：try, catch 和finally示例

try ... catch...finally 详细流程

捕获和处理多个异常

示例1：多个捕获块

在catch块中处理多个异常

示例2：单个catch块中捕获多个异常

捕获基本异常

示例3：仅捕获基本异常类

示例4：捕获基类和子异常类

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

支付宝扫一扫领取红包，优惠每天领

二维码1

二维码2