首页 > 编程笔记 > Java笔记 阅读：149

什么是异常，Java异常详解

通义灵码
Java 中的错误我们大致可以分为两类，一类是编译时错误，一般指语法错误；另一类是运行时错误。

我们知道，Java 程序运行首先需要进行编译，将 Java 文件编译成计算机能够识别的字节码文件，这类错误在程序编译时就会暴露出来，会导致程序编译失败。IDE 集成开发环境都会对这种错误进行提示，即我们在编写代码时能看到的语法错误，就叫编译时错误。因为可以即时看到，所以这种错误一般都能避免。

运行时错误在我们编写代码的过程中以及程序编译期间都难以发现，甚至可以正常编译通过，但一旦运行就会报错，这类错误一般不容易发现。编写代码的过程中往往会因为疏忽导致运行时错误的出现，例如数组下标越界，把 0 当作除数等。

Java 是一门面向对象的编程语言，世间万物都可以看作对象，那么同理错误也可以看作一个对象。Java 中有一组类专门来描述各种不同的运行时错误，叫作异常类。

Java 结合异常类提供了处理错误的机制，具体步骤就是当程序出现错误时，会创建一个包含错误信息的异常类的实例化对象，并将该对象提交给系统，由系统转交给能处理该异常的代码进行处理。

Java 将异常分为两类，包括 Error 和 Exception。Error 指系统错误，由 Java 虚拟机生成，我们编写的程序无法处理。Exception 指程序运行期间出现的错误，我们编写的程序可以对其进行处理。

举个生活中的例子来类比 Error 和 Exception。当你骑自行车出去玩时，如果半路自行车链条掉了，我们把链条重新安装就可以继续骑行，这属于自己可以处理的问题，就是 Exception。如果前方的路塌陷了，所有车都无法通过了，这属于我们无法处理的问题，就是 Error。

异常的使用

异常的使用需要用到两个关键字 try 和 catch，并且这两个关键字需要结合起来使用，用 try 来监听可能会抛出异常的代码，一旦捕获到异常，生成异常对象并交给 catch 来处理，基本语法如下：
try{
     //可能抛出异常
}catch(异常对象){
     //处理异常
}
举个简单的例子： 
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         try {
  4.             int num = 10/0;
  5.         }catch (Exception e) {
  6.             // TODO: handle exception
  7.             e.printStackTrace();
  8.         }
  9.     }
  10. }
运行结果为：

java.lang.ArithmeticException: / by zero
      at Test.main(test.java:4)

可以看到因为“int num = 10/0;”代码中将 0 作为除数，所以程序在执行时会产生错误并自动生成一个 Exception 对象，在 catch 代码块中捕获 Exception 对象并进行处理，将错误信息打印出来。

如果我们将代码修改为“int num = 10/10;”再次运行，就不会看到异常信息了。因为此时没有发生错误，就不会产生 Exception 对象，catch 代码块不执行。

以上代码是异常最基本的使用，通常除了使用 try 和 catch 关键字，我们还需要用到 finally 关键字，这个关键字有什么作用呢？无论程序是否抛出异常，finally 代码块中的程序都会执行。finally 一般跟在 catch 代码块后面，基本语法如下：
try{
     //可能抛出异常
}catch(异常对象){
     //处理异常
}finally{
     //必须执行的代码
}
例如： 
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         try {
  4.             int num = 10/0;
  5.         }catch (Exception e) {
  6.             // TODO: handle exception
  7.             e.printStackTrace();
  8.         }finally {
  9.             System.out.println("finally...");
  10.         }
  11.     }
  12. }
运行结果为：

java.lang.ArithmeticException: / by zero
finally...
      at Test.main(Test.java:4)


现在我们对代码进行修改，不使用 finally，而在 catch 代码块后面直接执行“System.out.println("finally...");”，代码如下： 
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         try {
  4.             int num = 10/0;
  5.         }catch (Exception e) {
  6.             // TODO: handle exception
  7.             e.printStackTrace();
  8.         }
  9.         System.out.println("finally...");
  10.     }
  11. }
运行结果为：

java.lang.ArithmeticException: / by zero
finally...
      at Test.main(Test.java:4)

可以看到结果完全一样，那么大家可能就会有疑问了，既然结果完全一样，那么为什么要使用 finally 呢？别着急，看完下面这个例子你就明白了。

定义一个带有返回值的方法 test，在该方法中加入 try-catch，例如：
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         System.out.println(test());
  4. }
  5.     public static int test() {
  6.         try {
  7.             System.out.println("try...");
  8.             return 10;
  9.         }catch (Exception e) {
  10.             // TODO: handle exception
  11.         }
  12.         System.out.println("finally...");
  13.         return 20;
  14.     }
  15. }
运行结果为：

try...
10

通过结果可以看到，try 代码块中进行了 return 操作，所以后续的代码都不会执行。

现在对代码进行修改，代码如下： 
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         System.out.println(test());
  4. }
  5.     public static int test() {
  6.         try {
  7.             System.out.println("try...");
  8.             return 10;
  9.         }catch (Exception e) {
  10.             // TODO: handle exception
  11.         }finally {
  12.             System.out.println("finally...");
  13.             return 20;
  14.         }
  15.     }
  16. }
运行结果为：

try...
finally...
20

通过结果可以看到，虽然 try 代码块中执行了 return 操作，但是 finally 代码块中的程序依然会执行，并且会覆盖 try 中 return 的结果，返回给外部调用者，正是因为 finally 的这个特性，一般会在 finally 中进行释放资源的操作。

异常类

Java 将运行时出现的错误全部封装成类，并且不是一个类，而是一组类。同时这些类之间是有层级关系的，由树状结构一层层向下分级，处在最顶端的类是 Throwable，是所有异常类的根结点。Throwable 有两个直接子类：Error 和 Exception，这两个类前面已经提到了。Error 表示系统错误，程序无法解决；Exception 指程序运行时出现的错误，程序可以处理。Throwable、Error 和 Exception 都存放在 java.lang 包中。

Error 常见的子类有 VirtualMachineError、AWTError、IOError。VirtualMachineError 的常见的子类有 StackOverflowError 和 OutOfMemoryError，用来描述内存溢出等系统问题。VirtualMachineError、StackOverflowError 和 OutOfMemoryError 都存放在 java.lang 包中，AWTError 存放在 java.awt 包中，IOError 存放在 java.io 包中。

Exception 常见的子类主要有 IOException 和 RuntimeException，IOException 存放在 java.io 包中，RuntimeException 存放在 java.lang 包中。Exception 类要重点关注，因为这部分异常是需要我们在编写代码的过程中手动进行处理的。

IOException 的常用子类有 FileLockInterruptionException、FileNotFoundException 和 FilerException，这些异常通常都是处理通过 IO 流进行文件传输时发生的错误，在后面 IO 流的章节我们会详细讲解。FileLockInterruptionException 存放在 java.nio.channels 包中，FileNotFoundException 存放在 java.io 包中，FilerException 存放在 javax.annotation.processing 包中。

RuntimeException的常用子类如下。
它们全部存放在 java.lang 包中。异常类的体系结构如下图所示。

图 1 Java异常类的体系结构

以上我们列举出了实际开发中经常使用到的异常类，还有很多没有列举出来，感兴趣的读者可以自己去查找 API 文档。除了使用 Java 官方提供的异常类，我们也可以根据需求自定义异常类。

throw和throws

throw 和 throws 是 Java 在处理异常时使用的两个关键字，都用来抛出异常，但是使用的方式以及表示的含义完全不同，接下来就带领大家一起来学习二者的区别。

Java 中抛出异常有 3 种方式，第 1 种是我们之前介绍过的使用 try-catch 代码块捕获异常。这种方式其实是一种防范机制，即代码中有可能会抛出异常。如果抛出，则捕获并进行处理；如果不抛出，则程序继续向后执行。例如： 
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         String str = "Java";
  4.         try {
  5.             Integer num = Integer.parseInt(str);
  6.         }catch (Exception e) {
  7.             // TODO: handle exception
  8.             e.printStackTrace();
  9.         }
  10.     }
  11. }
运行结果为：

java.lang.NumberFormatException: For input string: "Java"
     at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:67)
     at java.base/java.lang.Integer.parseInt(Integer.java:668)
     at java.base/java.lang.Integer.parseInt(Integer.java:786)
     at Test.main(Test.java:5)

可以看到结果抛出了类型转换的异常，不能将 String 类型的"Java"转为 int 类型的数据。同时在代码中我们不添加 try-catch 代码块，但结果是一样的： 
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         String str = "Java";
  4.         Integer num = Integer.parseInt(str);
  5.     }
  6. }
运行结果为：

Exception in thread "main" java.lang.NumberFormatException: For input string: "Java"
     at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:67)
     at java.base/java.lang.Integer.parseInt(Integer.java:668)
     at java.base/java.lang.Integer.parseInt(Integer.java:786)
     at Test.main(Test.java:4)

可以看到结果完全一样，为什么我们不添加 try-catch 代码块，程序同样可以抛出异常呢？

答案是 Java 有非常完善的错误处理机制，即使开发者不主动在程序中进行异常捕获，Java 虚拟机也会自动完成异常处理。这相当于员工因为疏忽没有把工作做好，老板会在汇总工作时发现问题并帮员工解决，保证最终的工作成果没有问题。但是很显然这种方式不是很好，不能总让老板去处理错误，员工在做本职工作时应该把所有问题都处理好。

回到代码中也是一样的道理，我们在编写程序时应尽量将异常进行处理，这个工作不要交给 Java 虚拟机去处理。如果我们进行如下修改，程序就不会抛出异常： 
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         String str = "10";
  4.         Integer num = Integer.parseInt(str);
  5.     }
  6. }
使用 throw 是开发者主动抛出异常，即读到 throw 代码就一定会抛出异常，基本语法：“throw new Exception();”，这是一种基于代码的逻辑判断从而主动抛出异常的方式，例如： 
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         String str = "Java";
  4.         if(str.equals("Java")) {
  5.             throw new NumberFormatException();
  6.         }else {
  7.             int num = Integer.parseInt(str);
  8.         }
  9.     }
  10. }
运行结果为：

Exception in thread "main" java.lang.NumberFormatException
     at Test.main(Test.java:5)

在上述代码中，我们主动对 str 进行判断，如果 str 的值为"Java"，则直接抛出 Number- FormatException 异常。所以 try-catch 是捕获可能抛出的异常，throw 是确定会抛出异常，这是二者的区别。

那么 throws 是如何抛出异常的呢？try-catch 和 throw 都是作用于具体的逻辑代码，throws 则是作用于方法，用来描述该方法可能会抛出的异常，具体实现如下： 
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         try {
  4.             test();
  5.         } catch (NumberFormatException e) {
  6.             // TODO: handle exception
  7.             e.printStackTrace();
  8.         }
  9.     }
  10.     public static void test() throws NumberFormatException{
  11.         String str = "Java";
  12.         int num = Integer.parseInt(str);
  13.     }
  14. }
test() 方法在定义时通过 throws 关键字声明了该方法可能会抛出 NumberFormatException 异常，所以我们在调用该方法时，需要手动使用 try-catch 进行捕获。同时 catch 代码块中可以捕获 NumberFormatException，也可以捕获 Exception，这两种方式都是没问题的，例如： 
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         try {
  4.             test();
  5.         } catch (Exception e) {
  6.             // TODO: handle exception
  7.             e.printStackTrace();
  8.         }
  9.     }
  10.     public static void test() throws NumberFormatException{
  11.         String str = "Java";
  12.         int num = Integer.parseInt(str);
  13.     }
  14. }
为什么这里捕获 NumberFormatException 和 Exception 都可以呢？因为 Java 的多态特性。

我们在前面的章节中介绍过面向对象的三大特征之一的多态，NumberFormatException 是具体的数值类型转换异常，Exception 是所有异常的父类。NumberFormatException 也可以理解成 Exception 的另外一种表现形式，这里我们使用这两类异常都是可以的。同时在调用 test 方法时，可以使用 try-catch 主动捕获，也可以不添加 try-catch，直接交给 Java 虚拟机来处理异常。所以这种情况下，加不加 try-catch 都是可以的，但是建议添加。

既然我们在 catch 中可以使用多态来捕获异常，那么在方法定义时也可以使用多态来描述可能发生的异常，即代码可以做如下修改： 
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         try {
  4.             test();
  5.         } catch (Exception e) {
  6.             // TODO: handle exception
  7.             e.printStackTrace();
  8.         }
  9.     }
  10.     public static void test() throws Exception{
  11.         String str = "Java";
  12.         int num = Integer.parseInt(str);
  13.     }
  14. }
但是在这种情况下，main 方法在调用 test 方法时就必须手动进行捕获。这里需要注意，如果方法抛出 RunntimeException 异常或者其子类异常，外部调用该方法时可以不进行 try-catch 捕获。如果方法抛出的是 Exception 异常或者其子类异常，则外部调用时必须进行 try-catch 捕获，否则会报错，如下图所示。


图 2 报错

如果不添加 try-cath，也可以通过让 main 方法抛出该异常的方式来解决这个错误，代码如下：
  1. public class Test {
  2.     public static void main(String[] args) throws Exception {
  3.         test();
  4.     }
  5.     public static void test() throws Exception{
  6.         String str = "Java";
  7.         int num = Integer.parseInt(str);
  8.     }
  9. }
test() 方法声明时会抛出 Exception，主方法中的代码在调用 test() 方法时就需要对异常进行处理，这里选择将异常抛出，那么抛出的异常是交给谁来处理的呢？你一定知道答案的！没错，就是交给 Java 虚拟机来处理了。

自定义异常类

在实际开发中，我们除了使用 Java 提供的异常类之外，也可以根据需求来自定义异常类，比如定义一个方法，对传入的参数进行 ++ 操作并返回，同时要求参数必须是整数类型，如果传入的参数不是整数类型则抛出自定义异常，具体实现如下： 
  1. public class MyNumberException extends Exception {
  2.     public MyNumberException(String error) {
  3.         super(error);
  4.     }
  5. }
  6.  
  7. public class Test {
  8.     public static void main(String[] args) {
  9.         Test test = new Test();
  10.         try {
  11.             int num = test.add("hello");
  12.         } catch (MyNumberException e) {
  13.             // TODO Auto-generated catch block
  14.             e.printStackTrace();
  15.         }
  16.     }
  17.     public int add(Object object) throws MyNumberException {
  18.         if(!(object instanceof Integer)) {
  19.             String error = "传入的参数不是整数类型";
  20.             throw new MyNumberException(error);
  21.         }else {
  22.             int num = (int) object;
  23.             return num++;
  24.         }
  25.     }
  26. }
add() 方法定义时声明了可能会抛出 MyNumberException 异常，是 Exception 的子类，所以在 main 方法中调用 add() 方法时需要手动进行处理，上述代码我们是通过 try-catch 的方式处理的，同时也可以直接让 main 方法抛出异常，代码如下： 
  1. public class Test {
  2.     public static void main(String[] args) throws MyNumberException {
  3.         Test test = new Test();
  4.         int num = test.add("hello");
  5.     }
  6.     public int add(Object object) throws MyNumberException {
  7.         if(!(object instanceof Integer)) {
  8.             String error = "传入的参数不是整数类型";
  9.             throw new MyNumberException(error);
  10.         }else {
  11.             int num = (int) object;
  12.             return num++;
  13.         }
  14.     }
  15. }
两种方式的运行结果一样。

推荐使用手动 try-catch 的方式，谁调用谁处理，不要把所有的任务都交给 Java 虚拟机来处理。

这里我们需要注意，Java 中有些异常在 throw 之后，还需要在方法定义处添加 throws 声明，有些异常则不需要，直接 throw 即可。这是因为 Exception 的异常分 checked exception 和 runtime exception，checked exception 表示需要强制去处理的异常，即 throw 异常之后需要立即处理，要么自己 try-catch，要么抛给上一层去处理，否则会报错，例如“Unhandled exception type Exception”。而 runtime exception 没有这个限制，throw 之后可以不处理。

直接继承自 Exception 的类就是 checked exception，继承自 RuntimeException 的类就是 runtime exception。我们自定义的 MyNumberExcpetion 是直接继承 Exception的，所以需要在 add() 方法定义处声明 throws MyNumberExcpetion。

相关文章