java异常处理机制详解

Posted 2021-03-21 xtslife

---

---

java异常处理机制详解

程序很难做到完美，不免有各种各样的异常。比如程序本身有bug，比如程序打印时打印机没有纸了，比如内存不足。为了解决这些异常，我们需要知道异常发生的原因。对于一些常见的异常，我们还可以提供一定的应对预案。C语言中的异常处理是简单的通过函数返回值来实现的，但返回值代表的含义往往是由惯例决定的。程序员需要查询大量的资料，才可能找到一个模糊的原因。面向对象语言，比如C++, Java, Python往往有更加复杂的异常处理机制。这里讨论Java中的异常处理机制。

异常处理

Java的异常处理机制很大一部分来自C++。它允许程序员跳过暂时无法处理的问题，以继续后续的开发，或者让程序根据异常做出更加聪明的处理。

Java使用一些特殊的对象来代表异常状况，这样对象称为异常对象。当异常状况发生时，Java会根据预先的设定，抛出(throw)代表当前状况的对象。所谓的抛出是一种特殊的返回方式。该线程会暂停，逐层退出方法调用，直到遇到异常处理器(Exception Handler)。异常处理器可以捕捉(catch)的异常对象，并根据对象来决定下一步的行动，比如:

• 提醒用户
• 处理异常
• 继续程序
• 退出程序

异常处理器看起来如下，它由try, catch, finally以及随后的程序块组成。finally不是必须的。

try {
   // try块中放可能发生异常的代码。
   // 如果执行完try且不发生异常，则接着去执行finally块和finally后面的代码（如果有的话）。
   // 如果发生异常，则尝试去匹配catch块。
}
 
catch() {
  // 每一个catch块用于捕获并处理一个特定的异常，或者这异常类型的子类。Java7中可以将多个异常声明在一个catch中。
  // catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的，则虚拟机将使用这个catch块来处理异常。
  // 在catch块中可以使用这个块的异常参数来获取异常的相关信息。异常参数是这个catch块中的局部变量，其它块不能访问。
  // 如果当前try块中发生的异常在后续的所有catch中都没捕获到，则先去执行finally，然后到这个函数的外部caller中去匹配异常处理器。
  // 如果try中没有发生异常，则所有的catch块将被忽略。
}
 
catch() {
 
 ...;
 
}
 
finally {
  // finally块通常是可选的。
  // 无论异常是否发生，异常是否匹配被处理，finally都会执行。
  // 一个try至少要有一个catch块，否则， 至少要有1个finally块。但是finally不是用来处理异常的，finally不会捕获异常。
// 如果在try或者catch语句中存在return语句，则return语句会在finally语句执行结束后执行，但是finally并不能改变返回值。
// 如果在finally语句中也有return，那么try和catch中的return语句会丢失，实际会返回finally中的返回值。
 // finally主要做一些清理工作，如流的关闭，数据库连接的关闭等。
}

这个异常处理器监视try后面的程序块。catch的括号有一个参数，代表所要捕捉的异常的类型。catch会捕捉相应的类型及其衍生类。catch后面的程序块包含了针对该异常类型所要进行的操作。try所监视的程序块可能抛出不止一种类型的异常，所以一个异常处理器可以有多个catch模块。finally后面的程序块是无论是否发生异常，都要执行的程序。

我们在try中放入可能出错，需要监视的程序，在catch中设计应对异常的方案。

下面是一段使用到异常处理的部分Java程序。try部分的程序是从一个文件中读取文本行。在读取文件的过程中，可能会有IOException发生:

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
try {
  StringBuilder sb = new StringBuilder();
  String line = br.readLine();
 
  while (line != null) {
    sb.append(line);
    sb.append("
");
    line = br.readLine();
  }
  String everything = sb.toString();
} 
catch(IOException e) {
  e.printStackTrace();
  System.out.println("IO problem");
}
finally {
  br.close();
}

如果我们捕捉到IOException类对象e的时，可以对该对象操作。比如调用对象的printStackTrace()，打印当前栈的状况。此外，我们还向中端打印了提示"IO problem"。

无论是否有异常，程序最终会进入finally块中。我们在finally块中关闭文件，清空文件描述符所占据的资源。

异常的类型

Java中的异常类都继承自Trowable类。一个Throwable类的对象都可以抛出(throw)。

橙色: unchecked; 蓝色: checked

Throwable对象可以分为两组。一组是unchecked异常，异常处理机制往往不用于这组异常，包括:

1.Error类通常是指Java的内部错误以及如资源耗尽的错误。当Error(及其衍生类)发生时，我们不能在编程层面上解决Error，所以应该直接退出程序。

2.Exception类有特殊的一个衍生类RuntimeException。RuntimeException(及其衍生类)是Java程序自身造成的，也就是说，由于程序员在编程时犯错。RuntimeException完全可以通过修正Java程序避免。比如将一个类型的对象转换成没有继承关系的另一个类型，即ClassCastException。这类异常应该并且可以避免。

剩下的是checked异常。这些类是由编程与环境互动造成程序在运行时出错。比如读取文件时，由于文件本身有错误，发生IOException。再比如网络服务器临时更改URL指向，造成MalformedURLException。文件系统和网络服务器是在Java环境之外的，并不是程序员所能控制的。如果程序员可以预期异常，可以利用异常处理机制来制定应对预案。比如文件出问题时，提醒系统管理员。再比如在网络服务器出现问题时，提醒用户，并等待网络服务器恢复。异常处理机制主要是用于处理这样的异常。

抛出异常

在上面的程序中，异常来自于我们对Java IO API的调用。我们也可以在自己的程序中抛出异常，比如下面的battery类，有充电和使用方法:

public class Test
{
  public static void main(String[] args)
  {
    Battery aBattery = new Battery();
    aBattery.chargeBattery(0.5);
    aBattery.useBattery(-0.5);
  }
}
 
class Battery 
{
  /**
   * increase battery
   */
  public void chargeBattery(double p)
  {
    // power <= 1
    if (this.power + p < 1.) {
      this.power = this.power + p;
    }
    else {
      this.power = 1.;
    }
  }
 
  /**
   * consume battery
   */
  public boolean useBattery(double p)
  {
    try {
      test(p);
    }
    catch(Exception e) {
      System.out.println("catch Exception");
      System.out.println(e.getMessage());
      p = 0.0;
    }
 
    if (this.power >= p) {
      this.power = this.power - p;
      return true;
    }
    else {
      this.power = 0.0;
      return false;
    }
  }
 
  /**
   * test usage
   */
  private void test(double p) throws Exception // I just throw, don't handle
  {
    if (p < 0) {
      Exception e = new Exception("p must be positive");
      throw e;
    }
  }
 
  private double power = 0.0; // percentage of battery
}

useBattery()表示使用电池操作。useBattery()方法中有一个参数，表示使用的电量。我们使用test()方法测试该参数。如果该参数为负数，那么我们认为有异常，并抛出。

在test中，当有异常发生时(p < 0)，我们创建一个Exception对象e，并用一个字符串作为参数。字符串中包含有异常相关的信息，该参数不是必需的。使用throw将该Exception对象抛出。

我们在useBattery()中有异常处理器。由于test()方法不直接处理它产生的异常，而是将该异常抛给上层的useBattery()，所以在test()的定义中，我们需要throws Exception来说明。

(假设异常处理器并不是位于useBattery()中，而是在更上层的main()方法中，我们也要在useBattery()的定义中增加throws Exception。)

在catch中，我们使用getMessage()方法提取其异常中包含的信息。上述程序的运行结果如下:

catch Exception
p must be positive

异常处理器中，我们会捕捉任意Exception类或者其衍生类异常。这往往不利于我们识别问题，特别是一段程序可能抛出多种异常时。我们可以提供一个更加具体的类来捕捉。

自定义异常

我们可以通过继承来创建新的异常类。在继承时，我们往往需要重写构造方法。异常有两个构造方法，一个没有参数，一个有一个String参数。比如:

class BatteryUsageException extends Exception
{
  public BatteryUsageException() {}
  public BatteryUsageException(String msg) {
    super(msg);
  }
}

我们可以在衍生类中提供更多异常相关的方法和信息。

在自定义异常时，要小心选择所继承的基类。一个更具体的类要包含更多的异常信息，比如IOException相对于Exception。

注意点

• try块中的局部变量和catch块中的局部变量（包括异常变量），以及finally中的局部变量，他们之间不可共享使用。
• 每一个catch块用于处理一个异常。异常匹配是按照catch块的顺序从上往下寻找的，只有第一个匹配的catch会得到执行。匹配时，不仅运行精确匹配，也支持父类匹配，因此，如果同一个try块下的多个catch异常类型有父子关系，应该将子类异常放在前面，父类异常放在后面，这样保证每个catch块都有存在的意义。
• finally块不管异常是否发生，只要对应的try执行了，则它一定也执行。只有一种方法让finally块不执行：System.exit()。因此finally块通常用来做资源释放操作：关闭文件，关闭数据库连接等等。良好的编程习惯是：在try块中打开资源，在finally块中清理释放这些资源。
• finally块没有处理异常的能力。处理异常的只能是catch块。

• 空指针异常

产生的原因

• 调用空对象的方法
• 获取或者修改一个对象不存在的字段
• 字符串变量未初始化
• 接口类型的对象没有，没有具体的类初始化
• 获取一个空数组的长度
• 获得或者修改空数组一个位置上的内容

解决方法

• 从已知的String对象中调用equals()和equalsIgnoreCase()方法，而非未知对象。

  Object unknownObject = null;
  
  //错误方式 – 可能导致 NullPointerException
  if(unknownObject.equals("knownObject")){
    System.err.println("This may result in NullPointerException if unknownObject is null");
  }
  
  //正确方式 - 即便 unknownObject是null也能避免NullPointerException
  if("knownObject".equals(unknownObject)){
    System.err.println("better coding avoided NullPointerException");
  }

• 当valueOf()和toString()返回相同的结果时，宁愿使用前者。

  igDecimal bd = getPrice();
  System.out.println(String.valueOf(bd)); //不会抛出空指针异常
  System.out.println(bd.toString()); //抛出 "Exception in thread "main" java.lang.NullPointerException"

• 使用null安全的方法和库 有很多开源库已经为您做了繁重的空指针检查工作。其中最常用的一个的是Apache commons 中的StringUtils。你可以使用StringUtils.isBlank()，isNumeric()，isWhiteSpace()以及其他的工具方法而不用担心空指针异常

//StringUtils方法是空指针安全的，他们不会抛出空指针异常
System.out.println(StringUtils.isEmpty(null));
System.out.println(StringUtils.isBlank(null));
System.out.println(StringUtils.isNumeric(null));
System.out.println(StringUtils.isAllUpperCase(null));
 
Output:
true
true
false
false

• 避免从方法中返回空指针，而是返回空collection或者空数组。Collections类提供了方便的空List，Set和Map: Collections.EMPTY_LIST，Collections.EMPTY_SET，Collections.EMPTY_MAP。这里是实例。

  public List getOrders(Customer customer){
    List result = Collections.EMPTY_LIST;
    return result;
  }

• 使用annotation@NotNull 和 @Nullable

• 避免你的代码中不必要的自动包装和自动解包。

  Person ram = new Person("ram");
  int phone = ram.getPhone();

• 遵从Contract并定义合理的默认值。

• 定义数据库中的字段是否可为空。

• **使用空对象模式（Null Object Pattern）

面试题目

题目一

package defineexception;
public class ExceptionTest3
{
    public void method()
    {
        try
        {
            System.out.println("try");
            return;
        }
        catch(Exception ex)
        {
            System.out.println("异常发生了");
        }
        finally
        {
            System.out.println("finally");
        }
        System.out.println("异常处理后续的代码");
    }
    public static void main(String[] args)
    {
        ExceptionTest3 test =new ExceptionTest3();
        test.method();
    }
}

结果：

try
finally

分析

try块中存在return语句，那么首先也需要将finally块中的代码执行完毕，再执行return语句，而且之后的其他代码也不会再执行了

题目二

package defineexception;
public class ExceptionTest3
{
    public void method()
    {
        try
        {
            System.out.println("try");
            System.exit(0);
        }
        catch(Exception ex)
        {
            System.out.println("异常发生了");
        }
        finally
        {
            System.out.println("finally");
        }
        System.out.println("异常处理后续的代码");
    }
    public static void main(String[] args)
    {
        ExceptionTest3 test =new ExceptionTest3();
        test.method();
    }
}

结果：

try

分析：

先执行try块中的System.exit(0)语句，已经退出了虚拟机系统，所以不会执行finally块的代码

总结

异常处理是在解决问题，同时也是在制造问题。大型项目中，过多、过细的异常处理往往会导致程序变得一团糟。异常处理的设计并不简单，并需要谨慎使用。