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();
  }
}

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

  1. try块中发生异常

  2. 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 异常处理以及如何捕获和处理多个异常_第1张图片

上图描述了在创建新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类的子类。 因此,我们抛出一个编译错误。

你可能感兴趣的:(Java异常处理,java,开发语言,算法)