异常是可能在程序执行期间发生的错误事件，它会破坏其正常流程。 Java提供了一种健壮且面向对象的方式来处理异常情况，称为Java异常处理 。 我们将在本教程中研究以下主题。

1. Java异常处理概述
2. 异常处理关键字
3. 异常层次
4. 有用的异常方法
5. Java 7自动资源管理和捕获块改进
6. 创建自定义异常类
7. 异常处理最佳实践

Java异常处理概述

我们不喜欢异常，但是我们总是要处理它们，好消息是Java异常处理框架非常健壮，易于理解和使用。 异常可能源于各种情况，例如用户输入的错误数据，硬件故障，网络连接故障，数据库服务器关闭等。在本节中，我们将学习如何在Java中处理异常。

Java是一种面向对象的编程语言，只要在执行一条语句时发生错误，就会创建一个异常对象 ，然后程序的正常流程会停止， JRE会设法找到可以处理引发异常的人。 异常对象包含许多调试信息，例如方法层次结构，发生异常的行号，异常类型等。当方法中发生异常时，将调用创建异常对象并将其移交给运行时环境的过程。 “抛出异常” 。

运行时一旦接收到异常对象，它将尝试查找该异常的处理程序。 异常处理程序是可以处理异常对象的代码块。 查找异常处理程序的逻辑很简单–在发生错误的方法中开始搜索，如果找不到合适的处理程序，则移至调用方方法，依此类推。 因此，如果方法调用堆栈为A-> B-> C且方法C中引发了异常，则对适当处理程序的搜索将从C-> B-> A转移。 如果找到合适的异常处理程序，则将异常对象传递给该处理程序以对其进行处理。 据说处理程序正在“捕获异常” 。 如果找不到合适的异常处理程序，则程序终止有关异常的打印信息。

请注意，Java异常处理是仅用于处理运行时错误的框架，异常处理框架不处理编译时错误。

我们在Java程序中使用特定的关键字来创建异常处理程序块，接下来我们将研究这些关键字。

异常处理关键字

Java提供了用于异常处理目的的特定关键字，我们将首先照顾它们，然后编写一个简单的程序，展示如何使用它们进行异常处理。

1. throw –我们知道，如果发生任何异常，将创建一个异常对象，然后Java运行时开始处理以处理它们。 有时我们可能想在代码中显式生成异常，例如，在用户身份验证程序中，如果密码为null，则应向客户端抛出异常。 throw关键字用于向运行时抛出异常以进行处理。
2. throws –当我们在方法中抛出任何异常而不对其进行处理时，我们需要在方法签名中使用throws关键字，以使调用程序知道该方法可能抛出的异常。 调用者方法可以处理这些异常，也可以使用throws关键字将其传播到其调用者方法。 我们可以在throws子句中提供多个异常，它也可以与main（）方法一起使用。
3. try-catch –我们在代码中使用try-catch块进行异常处理。 try是块的开始，catch是try块的末尾，用于处理异常。 我们可以使用try捕获多个catch块，并且try-catch块也可以嵌套。 catch块需要一个应为Exception类型的参数。
4. 最终 –最终块是可选的，只能与try-catch块一起使用。 由于异常会暂停执行过程，因此我们可能会打开一些不会关闭的资源，因此可以使用finally块。 无论是否发生异常，finally块都会始终执行。

让我们看一个简单的程序，显示Java中的异常处理。

package com.journaldev.exceptions;import java.io.FileNotFoundException;
import java.io.IOException;public class ExceptionHandling {public static void main(String[] args) throws FileNotFoundException, IOException {try{testException(-5);testException(-10);}catch(FileNotFoundException e){e.printStackTrace();}catch(IOException e){e.printStackTrace();}finally{System.out.println("Releasing resources");           }testException(15);}public static void testException(int i) throws FileNotFoundException, IOException{if(i < 0){FileNotFoundException myException = new FileNotFoundException("Negative Integer "+i);throw myException;}else if(i > 10){throw new IOException("Only supported for index 0 to 10");}}}

上面程序的输出是：

java.io.FileNotFoundException: Negative Integer -5at com.journaldev.exceptions.ExceptionHandling.testException(ExceptionHandling.java:24)at com.journaldev.exceptions.ExceptionHandling.main(ExceptionHandling.java:10)
Releasing resources
Exception in thread "main" java.io.IOException: Only supported for index 0 to 10at com.journaldev.exceptions.ExceptionHandling.testException(ExceptionHandling.java:27)at com.journaldev.exceptions.ExceptionHandling.main(ExceptionHandling.java:19)

注意，testException（）方法使用throw关键字引发异常，方法签名使用throws关键字使调用者知道它可能引发的异常类型。 在main（）方法中，我正在使用main（）方法中的try-catch块来处理异常，当我不处理它时，我将通过main方法中的throws子句将其传播到运行时。 注意，由于异常，永远不会执行testException(-10) ，然后在try-catch块执行后再执行finally块。 printStackTrace（）是Exception类中的一种有用方法，用于调试目的。

• 没有try语句，我们不能有catch或finally子句。
• 一个try语句应该具有catch块或finally块，它可以同时具有两个块。
• 我们不能在try-catch-finally块之间编写任何代码。
• 一个try语句可以包含多个catch块。
• try-catch块可以类似于if-else语句进行嵌套。
• 我们只有一个带有try-catch语句的finally块。

异常层次

如前所述，当引发任何异常时，将创建一个异常对象 。 Java异常是分层的， 继承用于对不同类型的异常进行分类。 Throwable是Java异常层次结构的父类，它具有两个子对象–错误和异常。 异常进一步分为检查异常和运行时异常。

1. 错误 ：错误是超出应用程序范围的特殊情况，无法预见并从中恢复，例如硬件故障，JVM崩溃或内存不足错误。 这就是为什么我们有一个单独的错误层次结构，我们不应该尝试处理这些情况。 一些常见的错误是OutOfMemoryError和StackOverflowError。
2. 检查异常 ：检查异常是我们可以在程序中预期并尝试从程序中恢复的异常情况，例如FileNotFoundException。 我们应该捕获该异常，并向用户提供有用的消息，并正确记录下来以进行调试。 Exception是所有Checked Exceptions的父类，如果要抛出一个Checked异常，则必须在同一方法中捕获它，否则必须使用throws关键字将其传播给调用方。
3. 运行时异常 ：运行时异常是由不良编程引起的，例如，尝试从数组中检索元素。 在尝试检索元素之前，我们应该先检查数组的长度，否则它可能在运行时引发ArrayIndexOutOfBoundException 。 RuntimeException是所有运行时异常的父类。 如果我们在方法中引发任何运行时异常，则无需在方法签名throws子句中指定它们。 更好的编程可以避免运行时异常。

有用的异常方法

异常及其所有子类均未提供任何特定方法，并且所有方法均在基类Throwable中定义。 创建异常类是为了指定不同类型的异常情况，以便我们可以轻松识别根本原因并根据异常类型进行处理。 Throwable类实现Serializable接口以实现互操作性。

Throwable类的一些有用方法是：

1. public String getMessage（） –此方法返回Throwable消息字符串，并且可以通过其构造函数创建异常时提供该消息。
2. public String getLocalizedMessage（） –提供此方法，以便子类可以重写它以向调用程序提供特定于语言环境的消息。 此方法的可抛出类实现仅使用getMessage()方法即可返回异常消息。
3. 公共同步Throwable getCause（） –此方法返回异常的原因，或者返回null id，原因未知。
4. public String toString（） –此方法以String格式返回有关Throwable的信息，返回的String包含Throwable类的名称和本地化消息。
5. public void printStackTrace（） –此方法将堆栈跟踪信息打印到标准错误流，此方法已重载，我们可以传递PrintStream或PrintWriter作为参数，以将堆栈跟踪信息写入文件或流。

Java 7自动资源管理和捕获块改进

如果您在单个try块中捕获了很多异常，则您会注意到catch块代码看起来非常丑陋，并且主要由用于记录错误的冗余代码组成，请记住，Java 7的功能之一是改进了catch块，我们可以在单个catch块中捕获多个异常。 具有此功能的catch块如下所示：

catch(IOException | SQLException | Exception ex){logger.error(ex);throw new MyException(ex.getMessage());
}

存在一些约束，例如异常对象是最终对象，我们无法在catch块内对其进行修改，请在Java 7 Catch Block Improvements上阅读完整的分析。

在大多数情况下，我们使用finally块只是为了关闭资源，有时我们忘记关闭它们并在资源耗尽时获取运行时异常。 这些异常很难调试，我们可能需要调查使用该类型资源的每个位置，以确保我们将其关闭。 因此，java 7的改进之一是try-with-resources，我们可以在try语句本身中创建资源，并在try-catch块内使用它。 当执行从try-catch块执行时，运行时环境会自动关闭这些资源。 具有这种改进的try-catch块示例为：

try (MyResource mr = new MyResource()) {System.out.println("MyResource created in try-with-resources");} catch (Exception e) {e.printStackTrace();}

在Java 7自动资源管理中阅读有关此功能的详细说明。

创建自定义异常类

Java提供了许多异常类供我们使用，但是有时我们可能需要创建自己的自定义异常类，以通过适当的消息以及我们要引入以进行跟踪的任何自定义字段（例如错误代码）来通知调用方有关特定类型的异常的信息。 。 例如，假设我们编写了一种仅处理文本文件的方法，因此当其他类型的文件作为输入发送时，我们可以为调用者提供适当的错误代码。

这是自定义异常类的示例，并显示了其用法。

MyException.java

package com.journaldev.exceptions;public class MyException extends Exception {private static final long serialVersionUID = 4664456874499611218L;private String errorCode="Unknown_Exception";public MyException(String message, String errorCode){super(message);this.errorCode=errorCode;}public String getErrorCode(){return this.errorCode;}}

CustomExceptionExample.java

package com.journaldev.exceptions;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;public class CustomExceptionExample {public static void main(String[] args) throws MyException {try {processFile("file.txt");} catch (MyException e) {processErrorCodes(e);}}private static void processErrorCodes(MyException e) throws MyException {switch(e.getErrorCode()){case "BAD_FILE_TYPE":System.out.println("Bad File Type, notify user");throw e;case "FILE_NOT_FOUND_EXCEPTION":System.out.println("File Not Found, notify user");throw e;case "FILE_CLOSE_EXCEPTION":System.out.println("File Close failed, just log it.");break;default:System.out.println("Unknown exception occured, lets log it for further debugging."+e.getMessage());e.printStackTrace();}}private static void processFile(String file) throws MyException {       InputStream fis = null;try {fis = new FileInputStream(file);} catch (FileNotFoundException e) {throw new MyException(e.getMessage(),"FILE_NOT_FOUND_EXCEPTION");}finally{try {if(fis !=null)fis.close();} catch (IOException e) {throw new MyException(e.getMessage(),"FILE_CLOSE_EXCEPTION");}}}}

请注意，我们可以有一个单独的方法来处理从不同方法中获取的不同类型的错误代码，其中一些被消耗掉是因为我们可能不想为此通知用户，或者其中一些我们将返回以通知用户有关错误代码。问题。

在这里，我扩展了Exception，以便每当产生此异常时，都必须在方法中对其进行处理或将其返回给调用程序，如果我们扩展RuntimeException，则无需在throws子句中指定它。 这是一个设计决策，但是我始终喜欢检查异常，因为我知道调用任何方法并采取适当的措施来处理它们时可以得到哪些异常。

异常处理最佳实践

1. 使用特定的异常 -异常层次结构的基类没有提供任何有用的信息，这就是Java具有这么多异常类的原因，例如IOException以及其他子类，如FileNotFoundException，EOFException等。我们应该始终抛出并捕获特定的异常类，因此该调用者将轻松知道异常的根本原因并进行处理。 这使调试变得容易，并帮助客户端应用程序适当地处理异常。
2. 提早或失败 -我们应尽早提起异常。 考虑上面的processFile（）方法，如果将null参数传递给此方法，则会得到以下异常。

   Exception in thread "main" java.lang.NullPointerExceptionat java.io.FileInputStream.<init>(FileInputStream.java:134)at java.io.FileInputStream.<init>(FileInputStream.java:97)at com.journaldev.exceptions.CustomExceptionExample.processFile(CustomExceptionExample.java:42)at com.journaldev.exceptions.CustomExceptionExample.main(CustomExceptionExample.java:12)

   在调试时，我们将必须仔细查看堆栈跟踪，以识别异常的实际位置。 如果我们更改实现逻辑以如下所述检查这些异常；

   private static void processFile(String file) throws MyException {if(file == null) throw new MyException("File name can't be null", "NULL_FILE_NAME");
   //further processing
   }

   然后，异常堆栈跟踪将如下所示，以清晰的消息清楚地显示异常发生的位置。

   com.journaldev.exceptions.MyException: File name can't be nullat com.journaldev.exceptions.CustomExceptionExample.processFile(CustomExceptionExample.java:37)at com.journaldev.exceptions.CustomExceptionExample.main(CustomExceptionExample.java:12)

3. 延迟捕获 –由于Java强制处理已检查的异常或在方法签名中声明它，因此有时开发人员倾向于捕获异常并记录错误。 但是这种做法是有害的，因为调用程序不会收到有关该异常的任何通知。 仅当我们可以适当地处理异常时，才应捕获异常。 例如，在上述方法中，我将异常抛出给调用方方法以进行处理。 可能希望以不同方式处理异常的其他应用程序可以使用相同的方法。 在实现任何功能时，我们应始终将异常抛出给调用者，并让他们决定如何处理它。
4. 关闭资源 –由于异常会中断程序的处理，因此我们应在finally块中关闭所有资源，或使用Java 7 try-with-resources增强功能让Java运行时为您关闭它。
5. 记录异常 –我们应始终记录异常消息，并在抛出异常时提供清晰的消息，以便调用者可以轻松知道发生异常的原因。 我们应该始终避免空的catch块，它只​​会消耗异常，并且不会为调试提供任何有意义的异常细节。
6. 用于多个异常的单个catch块 –大多数时候，我们记录异常详细信息并向用户提供消息，在这种情况下，我们应该使用java 7功能在单个catch块中处理多个异常。 这种方法将减少我们的代码大小，并且看起来也会更干净。
7. 使用自定义异常 –最好在设计时定义异常处理策略，而不是抛出并捕获多个异常，我们可以使用错误代码创建自定义异常，并且调用程序可以处理这些错误代码。 创建实用程序方法来处理不同的错误代码并使用它也是一个好主意。
8. 命名约定和打包 –创建自定义异常时，请确保它以Exception结尾，以便从名称本身就可以清楚看出它是一个异常。 还要确保像在JDK中一样打包它们，例如IOException是所有IO操作的基本异常。
9. 明智地使用异常 –异常代价高昂，有时甚至根本不需要引发异常，我们可以向调用者程序返回一个布尔变量，以指示操作是否成功。 如果操作是可选的，并且您不希望程序因失败而卡住，则这很有用。 例如，在从第三方Web服务更新数据库中的股票报价时，如果连接失败，我们可能希望避免引发异常。
10. 记录抛出的异常 –使用javadoc @throws可以清楚地指定方法抛出的异常，这在为其他应用程序提供使用接口时非常有用。

这就是Java中异常处理的全部，希望您喜欢它并从中学到一些东西。

翻译自: https://www.javacodegeeks.com/2013/07/java-exception-handling-tutorial-with-examples-and-best-practices.html