1. Java中的异常概念
在Java中，异常是一种程序运行中出现的非正常情况。当程序执行到某一步骤而出现无法处理的情况（如除数为零、文件未找到等），系统会创建一个异常对象并抛出该异常。Java的异常系统通过Throwable类来管理异常和错误，包含以下两大类：
1.1 Exception（异常）
Exception表示可以恢复的错误，通常由程序引发，建议通过捕获和处理来让程序继续执行。它主要分为两种：
-
检查异常（Checked Exception）：必须捕获和处理的异常，编译器要求在方法声明中使用
throws关键字声明，或在方法内部通过try-catch捕获。
常见的检查异常包括：IOException：文件读写时可能出现，如文件未找到或无法读取。SQLException：数据库操作中的异常，例如查询失败。ClassNotFoundException：加载类失败时抛出，通常出现在反射相关的操作中。
示例：
import java.io.File; import java.io.FileInputStream; import java.io.IOException; public class CheckedExceptionDemo { public static void main(String[] args) { try { FileInputStream file = new FileInputStream(new File("test.txt")); // 文件可能不存在 } catch (IOException e) { System.out.println("捕获到IOException：" + e.getMessage()); } } }在上例中，
FileInputStream构造方法可能会抛出IOException，所以编译器要求必须捕获或抛出这个异常。 -
运行时异常（RuntimeException）：属于非检查异常（Unchecked Exception），编译器不强制要求捕获。尽管这些异常可以捕获和处理，但大多数情况下，我们应该通过改进代码来避免它们。
常见的运行时异常包括：NullPointerException：尝试访问空对象的属性或方法时抛出。ArrayIndexOutOfBoundsException：访问数组时索引超出数组的长度范围。ArithmeticException：除以零时抛出。
示例：
public class RuntimeExceptionDemo { public static void main(String[] args) { try { int result = 10 / 0; // 试图除以0，会导致ArithmeticException } catch (ArithmeticException e) { System.out.println("捕获到异常：" + e.getMessage()); } } }在这里，
ArithmeticException是RuntimeException的子类。即使不捕获，程序也可以正常编译，但运行时会抛出异常。
1.2 Error（错误）
Error一般指程序无法控制的、无法恢复的严重错误。它们通常由Java运行时引发，表示系统层面的问题，如资源不足或系统故障，不建议捕获这些错误，因为它们代表的是程序之外的系统异常，通常无法恢复。
常见的错误包括：
OutOfMemoryError：JVM内存不足时抛出。StackOverflowError：方法调用过深导致栈内存溢出，例如无限递归。InternalError：JVM内部错误，通常在特殊情况或底层故障时出现。
示例：
public class ErrorDemo {
public static void main(String[] args) {
try {
int[] largeArray = new int[Integer.MAX_VALUE]; // 尝试创建超大的数组
} catch (OutOfMemoryError e) {
System.out.println("捕获到内存不足错误：" + e.getMessage());
}
}
}
在这种情况下，虽然可以捕获OutOfMemoryError，但不推荐这样做，因为即便捕获到此错误，通常程序也已无法继续运行。
2. 捕获异常
捕获异常的主要目的是让程序在遇到异常时继续执行而不是直接终止。Java通过try-catch结构来捕获异常，并提供了finally块来执行一定的清理工作。捕获异常的关键字包括try、catch和finally。
- try：包含可能会抛出异常的代码块。
- catch：用于捕获并处理特定类型的异常。可以有多个
catch块，分别处理不同类型的异常。捕获到的异常对象包含了异常的详细信息，方便程序员了解异常的原因。 - finally：无论是否发生异常都会执行的代码块，常用于释放资源（如关闭文件或数据库连接）。
2.1捕获异常的结构
使用try-catch-finally时，结构如下：
try {
// 可能抛出异常的代码
} catch (异常类型1 e) {
// 异常类型1的处理代码
} catch (异常类型2 e) {
// 异常类型2的处理代码
} finally {
// 总会执行的代码
}
示例代码
下面是一个捕获异常的示例代码，其中可能抛出ArrayIndexOutOfBoundsException和ArithmeticException。
public class CatchDemo {
public static void main(String[] args) {
int[] numbers = {10, 20};
try {
int result = numbers[2] / 0; // 访问数组越界并除以零
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("捕获到数组越界异常：" + e.getMessage());
} catch (ArithmeticException e) {
System.out.println("捕获到算术异常：" + e.getMessage());
} finally {
System.out.println("无论如何，都会执行finally块");
}
}
}
在上面的代码中：
try块中包含两个异常风险：数组越界和除以零。- 每个
catch块捕获不同类型的异常，打印出异常信息。 finally块中的代码总会执行，无论是否抛出异常。
2.2多个catch块的使用
Java支持在一个try语句后面添加多个catch块，从而对不同类型的异常进行不同的处理。值得注意的是，catch块中的异常类型从具体到通用排序更为合适，因为子类异常需要先于父类异常捕获。
try {
// 可能抛出异常的代码
} catch (IOException e) {
System.out.println("捕获到IO异常");
} catch (Exception e) {
System.out.println("捕获到一般异常");
}
2.3使用finally释放资源
finally块的设计目的是确保关键的清理工作总会执行，比如关闭数据库连接、释放文件句柄等，即便在try块中出现了异常。
示例：
import java.io.FileInputStream;
import java.io.IOException;
public class FinallyDemo {
public static void main(String[] args) {
FileInputStream file = null;
try {
file = new FileInputStream("test.txt");
// 读取文件内容
} catch (IOException e) {
System.out.println("文件读取错误：" + e.getMessage());
} finally {
try {
if (file != null) file.close(); // 确保资源释放
} catch (IOException e) {
System.out.println("文件关闭错误：" + e.getMessage());
}
}
}
}
在该示例中，finally确保了FileInputStream对象即便在读取过程中出现异常，也会被正确关闭，避免资源泄漏。
3. 抛出异常
在Java中，当方法遇到异常情况无法处理时，可以通过throw关键字手动抛出异常，或在方法声明中使用throws关键字向调用者声明异常。这样做可以让调用方法的代码决定如何处理该异常。
3.1throw关键字
throw用于在程序运行中显式地抛出一个异常。通常用于抛出自定义异常或程序中特定条件不满足时触发的异常。
示例：
public class ThrowDemo {
public static void checkAge(int age) {
if (age < 18) {
throw new IllegalArgumentException("未满18岁，不允许访问。"); // 手动抛出异常
}
System.out.println("欢迎访问！");
}
public static void main(String[] args) {
try {
checkAge(15); // 调用方法时触发异常
} catch (IllegalArgumentException e) {
System.out.println("捕获到异常：" + e.getMessage());
}
}
}
在上面的代码中：
checkAge方法判断age是否小于18岁，如果是，就使用throw抛出IllegalArgumentException。main方法中捕获了IllegalArgumentException，并输出了异常消息。
3.2throws关键字
throws用于方法声明中，表明该方法可能会抛出某些异常。必须捕获或声明的检查异常（Checked Exception）需要在方法声明时使用throws关键字。
示例：
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class ThrowsDemo {
public static void readFile(String filePath) throws IOException {
FileInputStream file = new FileInputStream(new File(filePath)); // 可能抛出IOException
// 执行文件操作
file.close();
}
public static void main(String[] args) {
try {
readFile("test.txt"); // 处理可能的异常
} catch (IOException e) {
System.out.println("捕获到异常：" + e.getMessage());
}
}
}
在上面的代码中：
readFile方法声明了throws IOException，表示调用者需要处理或进一步声明IOException。main方法调用readFile并使用try-catch捕获IOException，避免程序崩溃。
3.3throw与throws的区别
- throw：用于方法内部，抛出异常对象；一个方法内部可以有多个
throw语句。 - throws：用于方法签名，声明该方法可能抛出的异常类型；一个方法签名中可以列出多个异常类型。
3.4多异常类型的声明
如果方法可能会抛出多种类型的异常，可以在方法声明中同时列出它们，方便调用者知道可能抛出的所有异常类型。
示例：
import java.io.FileNotFoundException;
import java.io.IOException;
public class MultipleThrowsDemo {
public static void processFile(String filePath) throws IOException, FileNotFoundException {
// 读取文件的代码
if (filePath == null) {
throw new FileNotFoundException("文件路径为空");
}
// 其他文件操作，可能抛出IOException
}
}
在上例中，processFile方法可能会抛出IOException或FileNotFoundException。这种写法方便调用者知道可能的异常情况并加以处理。
4. 自定义异常
Java提供了丰富的内置异常类，但有时内置异常类型无法完全描述具体的异常情况。此时可以定义自己的异常类，继承Exception或RuntimeException类，以满足特定的业务需求。
4.1自定义检查异常（Checked Exception）
自定义检查异常需继承Exception类。由于Exception属于检查异常，编译器会要求处理这种异常（通过try-catch或throws）。
示例：
// 自定义的检查异常
class AgeException extends Exception {
public AgeException(String message) {
super(message);
}
}
public class CustomCheckedExceptionDemo {
public static void checkAge(int age) throws AgeException {
if (age < 18) {
throw new AgeException("年龄不足18岁"); // 抛出自定义异常
}
System.out.println("年龄符合要求");
}
public static void main(String[] args) {
try {
checkAge(15); // 会抛出自定义的AgeException
} catch (AgeException e) {
System.out.println("捕获到自定义异常：" + e.getMessage());
}
}
}
在此代码中：
AgeException继承了Exception，并在构造方法中接受异常消息。- 在
checkAge方法中，当年龄小于18岁时，抛出AgeException，调用者需处理该异常。
4.2自定义运行时异常（Runtime Exception）
自定义的运行时异常继承RuntimeException类。运行时异常属于非检查异常，编译器不会强制要求处理，但可以选择捕获。
示例：
// 自定义的运行时异常
class InvalidScoreException extends RuntimeException {
public InvalidScoreException(String message) {
super(message);
}
}
public class CustomRuntimeExceptionDemo {
public static void checkScore(int score) {
if (score < 0 || score > 100) {
throw new InvalidScoreException("分数无效，应在0到100之间");
}
System.out.println("分数有效");
}
public static void main(String[] args) {
try {
checkScore(110); // 会抛出自定义的InvalidScoreException
} catch (InvalidScoreException e) {
System.out.println("捕获到自定义异常：" + e.getMessage());
}
}
}
在此代码中：
InvalidScoreException继承了RuntimeException，当分数不在0到100之间时抛出异常。- 因为它是运行时异常，
checkScore方法的调用者可以选择是否捕获该异常。
4.3自定义异常的最佳实践
- 命名：自定义异常的类名应当清晰描述异常的含义，通常以“Exception”作为后缀。
- 继承的选择：根据需要决定继承
Exception或RuntimeException。如果希望调用者必须处理该异常，继承Exception；如果是程序逻辑引发的异常，可继承RuntimeException。 - 构造方法：提供多个构造方法以支持不同的初始化方式，通常包括接受消息参数的构造方法。
示例：
// 支持多种构造方法的自定义异常
class BusinessException extends Exception {
public BusinessException() {
super("业务异常");
}
public BusinessException(String message) {
super(message);
}
public BusinessException(String message, Throwable cause) {
super(message, cause);
}
}
在上例中，BusinessException类提供了三个构造方法，方便在不同场景中使用，增强了异常的灵活性。
5. 断言（Assertions）
Java中的断言（Assertion）是一种用于在开发和测试时检查程序状态的工具，可以帮助发现程序中的逻辑错误。在运行时，断言表达式用于验证某些条件是否成立。如果断言失败（即条件不成立），程序会抛出一个AssertionError，通常导致程序终止。
5.1断言的语法和使用场景
Java断言通过assert关键字实现，基本语法如下：
assert 条件表达式 : 错误消息;
- 条件表达式：表示希望成立的条件。当条件为
false时，会触发断言失败。 - 错误消息（可选）：一个字符串或表达式，用于提示断言失败的原因，便于调试。
示例：
public class AssertionDemo {
public static void main(String[] args) {
int age = -1;
assert age >= 0 : "年龄不能为负数"; // 如果age小于0，会触发断言失败
System.out.println("年龄是：" + age);
}
}
在上面的代码中，如果age为负数，断言会失败并输出错误消息“年龄不能为负数”。
5.2启用和禁用断言
在Java中，断言默认是禁用的，仅在开发和测试环境中使用。要启用断言，需要在JVM启动时使用-ea参数（-enableassertions）：
java -ea AssertionDemo
要禁用断言（这是默认行为），可以使用-da参数（-disableassertions）：
java -da AssertionDemo
5.3使用断言的最佳实践
断言主要用于开发阶段，以便检测代码逻辑上的错误，推荐使用在以下场景中：
-
检查程序的内部状态
断言常用于验证程序运行中的假设条件是否成立。例如，检查方法参数、数据结构是否为空、数值范围等，帮助验证程序的正确性。 -
防止不可能的情况
断言可以用于捕获理论上不应该发生的情况。例如在else分支中加入断言，以确保没有意料之外的值。 -
限制性检查
断言可用于检查程序中不会由用户输入导致的异常情况，而是通过编程逻辑实现的。例如方法内部状态的约束关系、循环不变式等。
示例：
public int divide(int a, int b) {
assert b != 0 : "除数不能为零"; // 检查分母是否为零
return a / b;
}
在这个示例中，断言确保b不为零，这是逻辑上不会出现的情况，但可以在开发阶段验证程序逻辑的健全性。
5.4断言与异常的区别
断言和异常都用于处理异常情况，但它们有不同的侧重点和使用场景：
- 断言：主要用于开发和测试阶段，用于捕获程序中的逻辑错误。通常不应在生产环境中启用断言。断言的失败意味着代码中有逻辑错误，需要开发人员修复。
- 异常：主要用于运行时阶段，处理可能发生的错误。异常通常是可以被捕获和处理的，而断言是为了发现不应该发生的逻辑错误。
5.5不推荐使用断言的场景
-
不用于参数校验：如果方法的参数是公开API的一部分，不应该使用断言来校验参数。因为断言在生产环境中通常是关闭的，使用异常来处理更合适。
-
不用于替代异常处理：断言的目的是帮助开发阶段找到程序中的逻辑缺陷，不能用于替代异常处理。运行时的异常处理逻辑应该通过
try-catch完成，而不是断言。
5. Logging（日志）
Java中的日志（Logging）是用于记录程序在运行时的状态、异常信息和调试数据的机制。通过日志系统，可以跟踪程序的执行流程，帮助发现和解决问题。Java提供了多个日志框架，其中java.util.logging是内置的基础日志系统。
5.1为什么使用日志
在开发过程中，日志记录对调试和追踪代码非常有帮助。相比于直接使用System.out.println()输出调试信息，日志具有更强的控制性和灵活性。日志可以记录不同的严重级别的信息，并且可以方便地控制日志的输出位置（如控制台或文件）和格式。
5.2日志级别
Java中的日志通常分为不同的级别，从最高到最低严重级别依次为：
SEVERE：表示严重错误，导致程序可能无法继续运行。WARNING：表示潜在问题，但程序仍然可以继续运行。INFO：表示关键信息，记录程序的正常运行状态。CONFIG：表示配置信息，通常用于配置的初始化。FINE、FINER、FINEST：用于详细的调试信息。用于开发阶段，帮助分析程序运行细节。
5.3使用java.util.logging记录日志
java.util.logging包提供了Logger类来实现日志记录，以下是一些常见操作示例：
import java.util.logging.*;
public class LoggingDemo {
// 创建Logger对象
private static final Logger logger = Logger.getLogger(LoggingDemo.class.getName());
public static void main(String[] args) {
// 设置日志级别
logger.setLevel(Level.ALL);
// 添加日志信息
logger.severe("这是一个严重错误的日志");
logger.warning("这是一个警告信息的日志");
logger.info("这是一个普通信息的日志");
logger.config("这是配置信息的日志");
logger.fine("这是一个细节调试信息的日志");
}
}
在此代码中：
Logger.getLogger()方法用于创建或获取一个Logger实例。- 通过
logger.setLevel(Level.ALL)设置日志的最低级别为ALL，这样可以记录所有级别的日志信息。
5.4配置日志输出格式
可以通过修改日志配置文件或直接设置Handler来调整日志的输出格式。常见的Handler包括：
ConsoleHandler：将日志输出到控制台。FileHandler：将日志输出到文件。
示例：将日志输出到文件并设置格式
import java.io.IOException;
import java.util.logging.*;
public class FileLoggingDemo {
private static final Logger logger = Logger.getLogger(FileLoggingDemo.class.getName());
public static void main(String[] args) {
try {
// 创建FileHandler，将日志写入文件
Handler fileHandler = new FileHandler("app.log", true);
logger.addHandler(fileHandler);
// 设置日志的输出格式
SimpleFormatter formatter = new SimpleFormatter();
fileHandler.setFormatter(formatter);
logger.setLevel(Level.INFO);
logger.info("这是记录在文件中的日志信息");
} catch (IOException e) {
System.err.println("日志文件创建失败: " + e.getMessage());
}
}
}
在此示例中：
- 使用
FileHandler将日志写入文件app.log，设置SimpleFormatter格式化日志输出。 - 如果日志文件创建失败，捕获
IOException异常，避免程序崩溃。
5.5日志最佳实践
- 合理设置日志级别：只记录必要的信息。开发阶段可以使用较低级别的日志（如
FINE），生产环境通常只保留INFO或更高级别的日志。 - 避免敏感信息：避免在日志中记录用户的密码、密钥等敏感信息，确保安全性。
- 异常日志处理：遇到异常时，通过日志记录完整的异常信息，如异常类型、堆栈信息等，便于分析问题。
5.6常用的日志框架
除了java.util.logging，Java还支持其他功能更强的第三方日志框架，例如：
- Log4j：功能强大且高度可配置的日志框架，支持文件、数据库等多种输出格式。
- Logback：是Log4j的改进版本，性能更好，与
SLF4J（简单日志门面）兼容。 - SLF4J：提供了通用的日志接口，可以结合多种日志实现，通常配合Logback或Log4j使用。
使用这些第三方框架可以更灵活地配置日志格式、存储位置和输出级别，更适合复杂的企业应用。
扫一扫
245
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
