Java的基本使用之异常处理
2025-07-03 19:49:04
1、Java中异常的基本概念
异常是一种类，因此它本身带有类型信息。异常可以在任何地方抛出，但只需要在上层捕获。
在 Java 中抛出异常的目的是为了在代码执行发生错误的时候，停止，或者进行处理，以及抛出信息帮助程序员定位出现bug的位置。所以，我们需要在可能发生异常的地方抛出异常并进行捕获处理。
Java 中异常的继承关系如下：
由上图可知，Throwable是异常体系的根，它继承自Object。
所有异常都可以调用 e.printStackTrace() 方法进行简单打印输出。
1.1、Error 和 Exception
Throwable有两个体系：Error和Exception。
1.1.1、Error
Error表示严重的错误，程序对此一般无能为力，例如：
OutOfMemoryError：内存耗尽
NoClassDefFoundError：无法加载某个Class
StackOverflowError：栈溢出
1.1.2、Exception
而Exception则是运行时的错误，它可以被捕获并处理。
Exception分为两大类：
RuntimeException以及它的子类；
非RuntimeException（包括IOException、ReflectiveOperationException等等）
1.3、哪些异常需要被捕获
有些异常是应用程序逻辑处理的一部分，应该捕获并处理。例如：
NumberFormatException：数值类型的格式错误
FileNotFoundException：未找到文件
SocketException：读取网络失败
还有一些异常是程序逻辑编写不对造成的，应该修复程序本身。例如：
NullPointerException：对某个null的对象调用方法或字段。空指针异常，如果一个对象为null，调用其方法或访问其字段就会产生NullPointerException。指针这个概念实际上源自C语言，Java语言中并无指针。我们定义的变量实际上是引用，Null Pointer更确切地说是Null Reference，
IndexOutOfBoundsException：数组索引越界
Java规定：
必须捕获的异常：包括Exception及其子类，但不包括RuntimeException及其子类，这种类型的异常称为Checked Exception。
不需要捕获的异常：包括Error及其子类，RuntimeException及其子类。
2、捕获异常（try{...} catch(){...}）
在Java中，凡是可能抛出异常的语句，都可以用try ... catch进行捕获。通过捕获异常就可以针对异常情况做操作，并且避免后面的程序被中断。
只要是在方法抛出的 Checked Exception，如果不在该方法的调用层捕获，那就应该抛出来，然后在更高的调用层捕获。所有未捕获的异常，最终也必须在main()方法中捕获或者在 main 方法中抛出然后由 JVM 进行处理，否则会编译报错。main()方法是最后捕获异常的机会，不推荐在 main 方法中抛出异常。
在捕获了异常后我们应该进行相应的操作，至少应该打印记录异常。
public static void main(String[] args) {
try {
...
} catch (Exception e) {
e.printStackTrace();
}
}
我们可以使用多个 catch 语句，每个catch分别捕获对应的Exception及其子类。JVM在捕获到异常后，会从上到下匹配catch语句，匹配到某个catch后，执行catch代码块，然后不再继续匹配。简单地说就是多个catch语句只有一个能被执行。
存在多个catch的时候，子类必须写在前面，否则永远捕获不到该子类异常。
public static void main(String[] args) {
try {
process1();
} catch (UnsupportedEncodingException e) { //子类应该写在前面，否则永远捕获不到
System.out.println("Bad encoding");
} catch (IOException | NumberFormatException e) { //处理不同异常的代码一样时，我们可以用 | 把它们写在一起
System.out.println("Bad input");
}
}
2.1、finally 语句
Java 的try ... catch机制还提供了finally语句，finally语句块保证有无错误都会执行。
public static void main(String[] args) {
try {
...
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("END");
}
}
finally 语句不是必须的，可写可不写，并且它总是最后执行的，finally 语句是用来保证一些代码必须执行的。
你也可以只使用try ... finally，而不写catch语句，例如：
//下面方法声明了可能抛出的异常，所以可以不写catch。
void process(String file) throws IOException {
try {
...
} finally {
System.out.println("END");
}
}
在catch语句块中抛出异常，finally语句仍然会执行：
public class Main {
public static void main(String[] args) {
try {
Integer.parseInt("abc");
} catch (Exception e) {
System.out.println("catched");
throw new RuntimeException(e);
} finally {
System.out.println("finally");
}
}
}
//上述代码执行结果如下：
catched
finally
Exception in thread "main" java.lang.RuntimeException: java.lang.NumberFormatException: For input string: "abc"
at Main.main(Main.java:8)
Caused by: java.lang.NumberFormatException: For input string: "abc"
at ...
先打印了catched，后打印finally，然后再输出异常信息。说明先执行了catch语句，然后又执行了finally语句块，最后才抛出了异常并且在 JVM 中捕获。因此，在catch中抛出异常，不会影响finally的执行。JVM会先执行finally，然后才抛出异常。
3、抛出异常
当某个方法抛出了异常时，如果在调用该方法时没有捕获异常，那就应该抛出来，由更上层来进行捕获，以此类推，直到遇到某个try ... catch被捕获为止。所有未捕获的异常，最终也必须在main()方法中捕获或者在 main 方法中抛出然后由 JVM 进行处理，否则会编译报错。
3.1、如何抛出异常
抛出异常分两步：
创建某个Exception的实例；
用throw语句抛出。
代码示例：
public void process2(String s) {
if (s==null) {
NullPointerException e = new NullPointerException("异常信息");
throw e;
//一般写成一行即可
throw new NullPointerException("异常信息");
}
}
子类重写父类的方法时，子类方法不能抛出比父类方法更大的异常。
3.2、异常转换
如果一个方法使用 catch 捕获了某个异常后，又在 catch 语句中抛出新的异常，此时就相当于把抛出的异常类型“转换”了，此时如果在其他方法中捕获新异常，旧异常的信息不会被捕获到。
public class Main {
public static void main(String[] args) {
try {
process1();
} catch (Exception e) { //此时输出process1方法的异常，并不会输出process2方法中的异常信息
e.printStackTrace();
}
}
static void process1() {
try {
process2();
} catch (NullPointerException e) { //捕获process2方法的异常并转换
throw new IllegalArgumentException();
}
}
static void process2() {
throw new NullPointerException();
}
}
这样新的异常就会丢失原始异常信息，我们无法看不到原始异常NullPointerException的信息。
为了能追踪到完整的异常栈，在构造异常的时候，把原始的Exception实例传进去，新的Exception就可以持有原始Exception信息。对上述代码改进如下：
public class Main {
public static void main(String[] args) {
try {
process1();
} catch (Exception e) {
e.printStackTrace();
}
}
static void process1() {
try {
process2();
} catch (NullPointerException e) {
throw new IllegalArgumentException(e); //这里将原始的异常传了进去
}
}
static void process2() {
throw new NullPointerException();
}
}
//运行上述代码，打印出的异常栈类似以下信息：
//Caused by: Xxx，说明捕获的IllegalArgumentException并不是造成问题的根源，根源在于NullPointerException，是在Main.process2()方法抛出的。
java.lang.IllegalArgumentException: java.lang.NullPointerException
at Main.process1(Main.java:15)
at Main.main(Main.java:5)
Caused by: java.lang.NullPointerException
at Main.process2(Main.java:20)
at Main.process1(Main.java:13)
在代码中获取原始异常可以使用Throwable.getCause()方法。如果返回null，说明已经是“根异常”了。
捕获到异常并再次抛出时，一定要留住原始异常，否则很难定位第一案发现场！有了完整的异常栈的信息，我们才能快速定位并修复代码的问题。
4、打印异常信息（e.printStackTrace()）
所有异常都可以通过printStackTrace()打印出方法的调用栈，打印信息类似下面：
java.lang.NumberFormatException: null
at java.base/java.lang.Integer.parseInt(Integer.java:614)
at java.base/java.lang.Integer.parseInt(Integer.java:770)
at Main.process2(Main.java:16)
at Main.process1(Main.java:12)
at Main.main(Main.java:5)
上述信息表示：NumberFormatException是在java.lang.Integer.parseInt方法中被抛出的，从下往上看，调用层次依次是：
main()调用process1()；
process1()调用process2()；
process2()调用Integer.parseInt(String)；
Integer.parseInt(String)调用Integer.parseInt(String, int)。
每层调用都给出了源代码的行号，可直接定位。
5、使用日志（JDK Logging）
日志就是Logging，它的目的是为了取代System.out.println()。
5.1、使用日志的好处
可以设置输出样式，避免自己每次都写"ERROR: " + var
可以设置输出级别，禁止某些级别输出。例如，只输出错误日志
可以被重定向到文件，存档，这样可以在程序运行结束后查看日志，便于追踪问题
可以根据配置文件调整日志，无需修改代码
可以按包名控制日志级别，只输出某些包打的日志等等。。。
5.2、如何使用日志
Java 标准库内置了日志包java.util.logging，我们可以直接用。
import java.util.logging.Level;
import java.util.logging.Logger;
public class Hello {
public static void main(String[] args) {
Logger logger = Logger.getGlobal();
logger.info("start process...");
logger.warning("memory is running out...");
logger.fine("ignored.");
logger.severe("process will be terminated...");
}
}
//打印以下信息：
Mar 02, 2019 6:32:13 PM.Hello main //自动打印出时间、调用类、调用方法等很多有用的信息。
INFO: start process...
Mar 02, 2019 6:32:13 PM.Hello main
WARNING: memory is running out...
Mar 02, 2019 6:32:13 PM.Hello main
SEVERE: process will be terminated...
上面的输出当中，logger.fine()没有打印。这是因为，日志的输出可以设定级别。JDK 的 Logging 定义了7个日志级别，从严重到普通。默认级别是 INFO，INFO 级别以下的日志，不会被打印出来。使用日志级别的好处在于，调整级别，就可以屏蔽掉很多调试相关的日志输出。
日志级别如下：
SEVERE
WARNING
INFO
CONFIG
FINE
FINER
FINEST
Java标准库内置的Logging有以下局限：Logging系统在JVM启动时读取配置文件并完成初始化，一旦开始运行main()方法，就无法修改配置；配置不太方便，需要在JVM启动时传递参数-Djava.util.logging.config.file=
6、使用 Commons Logging
和Java标准库提供的日志不同，Commons Logging是一个第三方日志库，它可以挂接不同的日志系统，并通过配置文件指定挂接的日志系统。默认情况下，Commons Loggin自动搜索并使用Log4j，如果没有找到Log4j，再使用JDK Logging。
Commons Logging是一个第三方提供的库，要想使用必须先把它下载下来，链接：https://commons.apache.org/proper/commons-logging/download_logging.cgi
下载后，解压，找到commons-logging-1.2.jar这个文件，将 jar 文件放在项目根目录下，并且在 Libraries 中引入该 jar 文件，然后即可使用
//先通过LogFactory获取Log类的实例，然后使用Log实例的方法打日志
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class Main {
public static void main(String[] args) {
Log log = LogFactory.getLog(Main.class);
log.info("start...");
log.warn("end.");
}
}
Commons Logging定义了6个日志级别，默认级别是INFO，即INFO级别以下的都不会打印出来
FATAL
ERROR
WARNING
INFO
DEBUG
TRACE
7、使用 Log4j
Log4j是一种非常流行的日志框架，Commons Logging可以作为“日志接口”来使用，而真正的“日志实现”可以使用Log4j。
当我们使用 Log4j 输出一条日志时，Log4j 自动通过不同的 Appender 把同一条日志输出到不同的目的地
使用Log4j的时候我们可以通过配置文件来让 Log4j 读取配置文件并按照我们的配置来输出日志，例如：
有了配置文件还不够，因为Log4j也是一个第三方库，我们需要从这里（https://www.liaoxuefeng.com/wiki/1252599548343744/1264739436350112）下载Log4j，解压后，把以下3个jar包添加至项目依赖中
log4j-api-2.x.jar
log4j-core-2.x.jar
log4j-jcl-2.x.jar
把Commons Logging 添加至项目依赖中，Commons Logging会自动发现并使用Log4j。要打印日志，只需要按Commons Logging的写法写即可，不需要改动任何代码，就可以得到Log4j的日志输出。
在开发阶段，始终使用Commons Logging接口来写入日志，并且开发阶段无需引入Log4j。如果需要把日志写入文件， 只需要把正确的配置文件和Log4j相关的jar包放入classpath，就可以自动把日志切换成使用Log4j写入，不需要修改任何代码。
参考：https://www.liaoxuefeng.com/wiki/1252599548343744/1264739436350112