Java中的异常和处理

异常的概念​​​​​​

 

异常本质上是程序上的错误，包括程序逻辑错误和系统逻辑错误。比如：使用空的引用（NullPointerException）、数组下标越界（ArrayIndexOutOfBoundsException）、内存溢出错误（OutOfMemoryError）、代码少写一个分号，会提示 java.lang.Error 、除数为0时，会抛出 java.lang.ArithmeticException 等异常。

异常发生的原因有很多，通常包含以下几类：

• 用户输入了非法数据
• 要打开的文件不存在
• 网络通信时连接中断，或者JVM内存溢出

要理解Java异常处理是如何工作的，需要掌握以下三种类型的异常：

• 检查性异常(checked exception)：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的
• 运行时异常(RuntimeException)：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略
• 错误(Error)：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略

异常的体系结构

Java标准库内建了一些通用的异常，这些类以Throwable为顶层父类。

Throwable类又派生出Error类和Exception类。

错误：Error类以及它的子类的实例，代表了JVM本身的错误。错误是不能被程序员通过代码处理。Error很少出现，因此，程序员应该关注Exception为父类的分支下的各种异常类。

异常：Exception以及它的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。

Throwable是所有异常的根，java.lang.Throwable
Error是错误，java.lang.Error
Exception是异常，java.lang.Exception

Error是无法处理的异常，比如OutOfMemoryError，一般发生这种异常，JVM会选择终止程序，因此我们编写程序时不需要关心这些异常。

Exception，是我们常见的一些异常情况，比如NullPointerException、IndexOutOfBoundsException，这些异常都是我们可以处理的异常。

Exception类的异常包括checked exception和unchecked exception（unchecked exception也称运行时异常RuntimeException，当然这里的运行时异常并不是前面我所说的运行期间的异常，只是Java中用运行时异常这个术语来表示，Exception类的异常都是在运行期间发生的）。

unchecked exception（非检查异常），也称运行时异常（RuntimeException），比如常见的NullPointerException、IndexOutOfBoundsException。对于运行时异常，java编译器不要求必须进行异常捕获处理或者抛出声明，由程序员自行决定。

checked exception（检查异常），也称非运行时异常（运行时异常以外的异常就是非运行时异常），java编译器强制程序员必须进行捕获处理，比如常见的IOExeption和SQLException。对于非运行时异常如果不进行捕获或者抛出声明处理，编译都不会通过。

初识异常

下面的代码会演示2个异常类型：ArithmeticException 和 InputMismatchException。前者是由于整数除0引起，后者是输入的数据不能被转化为int类型引起。

package com.cj.test;

import java.util.Scanner;

public class AllDemo {
	public static void main(String[] args) {
		System.out.println("----欢迎使用命令行除法计算器----");
		CMDCalculate();
	}
	
	private static void CMDCalculate() {
		Scanner scan = new Scanner(System.in);
		int num1 = scan.nextInt();
		int num2 = scan.nextInt();
		int result = devide(num1,num2);
		System.out.println("result:"+result);
		scan.close();
	}
	
	public static int devide(int num1,int num2) {
		return num1/num2;
	}
}

两种错误提示：
----欢迎使用命令行除法计算器----
1
0
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.cj.test.AllDemo.devide(AllDemo.java:21)
	at com.cj.test.AllDemo.CMDCalculate(AllDemo.java:15)
	at com.cj.test.AllDemo.main(AllDemo.java:8)


----欢迎使用命令行除法计算器----
1
d
Exception in thread "main" java.util.InputMismatchException
	at java.util.Scanner.throwFor(Unknown Source)
	at java.util.Scanner.next(Unknown Source)
	at java.util.Scanner.nextInt(Unknown Source)
	at java.util.Scanner.nextInt(Unknown Source)
	at com.cj.test.AllDemo.CMDCalculate(AllDemo.java:14)
	at com.cj.test.AllDemo.main(AllDemo.java:8)

异常是在执行某个函数时引起的，而函数又是层级调用，形成调用栈的。因为，只要一个函数发生异常，那么它所有的caller都会被影响。当这些被影响的函数以异常信息输出时，就形成了异常追踪栈。

异常最先发生的地方，叫做异常抛出点。

从上面的例子可以看出，当devide函数发生除0异常时，devide函数将抛出ArithmeticException异常，因此调用他的CMDCalculate函数也无法正常完成，因此也发送异常，而CMDCalculate的caller——main 因为CMDCalculate抛出异常，也发生了异常，这样一直向调用栈的栈底回溯。这种行为叫做异常的冒泡，异常的冒泡是为了在当前发生异常的函数或者这个函数的caller中找到最近的异常处理程序。由于这个例子中没有使用任何异常处理机制，因此异常最终由main函数抛给JRE，导致程序终止。

上面的代码不使用异常处理机制，也可以顺利编译，因为2个异常都是非检查异常。但是下面的例子就必须使用异常处理机制，因为异常是检查异常。

代码中选择使用throws声明异常，让函数的调用者去处理可能发生的异常。但是为什么只throws了IOException呢？因为FileNotFoundException是IOException的子类，在处理范围内，所以不要把上层类的异常放在最前面的catch块。

@Test
public void testException() throws IOException
{
    //FileInputStream的构造函数会抛出FileNotFoundException
    FileInputStream fileIn = new FileInputStream("E:\\a.txt");
 
    int word;
    //read方法会抛出IOException
    while((word =  fileIn.read())!=-1) 
    {
        System.out.print((char)word);
    }
    //close方法会抛出IOException
    fileIn.clos
}

异常处理的基本语法

Java异常处理涉及到五个关键字，分别是：try、catch、finally、throw、throws。下面将骤一介绍，通过认识这五个关键字，掌握基本异常处理知识。

　　• try  -- 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，异常就被抛出。
　　• catch   -- 用于捕获异常。catch用来捕获try语句块中发生的异常。
　　• finally  -- finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。                         只有finally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语句，如果finally中使用了 return                         或者throw等终止方法的语句，则就不会跳回执行，直接停止。
　　• throw   -- 用于抛出异常。
　　• throws -- 用在方法签名中，用于声明该方法可能抛出的异常。

在编写代码处理异常时，对于检查异常，由2种不同的处理方式：使用try····catch····finally语句块处理它。或者，在函数签名中使用throws声明交给函数调用者caller去解决。

try····catch····finally语句块：

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

注意：

1. try块中的局部变量和catch块中的局部变量（包括异常变量），以及finally中的局部变量，它们之间不可共享使用

2. 每一个catch块用于处理一个异常。异常匹配是按照catch块的顺序从上往下寻找的，只有第一个匹配的catch会得到执行。匹配时，不仅运行精确匹配，也支持父类匹配。因此，如果同一个try块下的多个catch异常类型有父子关系，应该将子类异常放在前面，父类异常放在后面，这样保证每个catch块都有存在的意义。

顺序问题：先小后大，即先子类后父类

3. java中，异常处理的任务就是将执行控制流从异常发生的地方转移到能够处理这种异常的地方去。也就是说：当一个函数的某条语句发生异常时，这条语句的后面的语句不会再执行，它失去了焦点。执行流跳转到最近的匹配的异常处理catch代码块去执行，异常被处理完后，执行流会接着在“处理了这个异常的catch代码块”后面接着执行。
有的编程语言当异常被处理后，控制流会恢复到异常抛出点接着执行，这种策略叫做：resumption model of exception handling（恢复式异常处理模式 ）
而Java则是让执行流恢复到处理了异常的catch块后接着执行，这种策略叫做：termination model of exception handling（终结式异常处理模式）

public static void main(String[] args){
        try {
            foo();
        }catch(ArithmeticException ae) {
            System.out.println("处理异常");
        }
}
public static void foo(){
        int a = 5/0;  //异常抛出点
        System.out.println("为什么还不给我涨工资!!!");  //不会执行
}

throws函数声明：

throws声明：如果一个方法内部的代码会抛出检查异常（checked exception）,而方法自己又没有完全处理掉，则javac保证你必须在方法的签名上使用throws关键字声明这些可能抛出的异常，否则编译不通过

throws是另一种处理异常的方式，它不同于try····catch····finally，throws仅仅是将函数中可能出现的异常向调用者声明，而自己则不具体处理

采取这种异常处理的原因可能是：方法本身不知道如何处理这样的异常，或者说让调用者处理更好，调用者需要为可能发生的异常负责

public void foo() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN
{ 
     //foo内部可以抛出 ExceptionType1 , ExceptionType2 ,ExceptionTypeN 类的异常，或者他们的子类的异常对象。
}

finally块

finally块不管异常是否发生，只要对应的try执行了，则它一定也执行。只有一种方法让finally块不执行：System.exit()。因此finally块通常用来做资源释放操作：关闭文件，关闭数据库连接等等

良好的编程习惯是：在try块中打开资源，在finally块中清理释放这些资源

注意：

1. finally块没有处理异常的能力，处理异常的只能是catch块

2. 在同一个try····catch····finally块中，如果try中抛出异常，且有匹配的catch块，则先执行catch块，再执行finally块。如果没有catch块，则先执行finally块，然后去办外面的调用者中寻找合适的catch块

3. 在同一try…catch…finally块中 ，try发生异常，且匹配的catch块中处理异常时也抛出异常，那么后面的finally也会执行：首先执行finally块，然后去外围调用者中寻找合适的catch块

throw异常抛出语句

throw语法形式：throw exceptionObject

1. throw只会出现在方法体中，当方法在执行过程中遇到异常情况时，将异常信息封装为异常对象，然后throw出去。throw关键字的一个非常重要的作用就是 异常类型的转换

2. throw抛出了异常，执行throw则一定抛出了某种异常对象

3. 程序执行完throw语句之后立即停止；throw后面的任何语句不被执行，最邻近的try块用来检查它是否含有一个与异常类型匹配的catch语句。如果发现了匹配的块，控制转向该语句；如果没有发现，次包围的try块来检查，以此类推。如果没有发现匹配的catch块，默认异常处理程序中断程序的执行并且打印堆栈轨迹

finally块和return

• 在 try块中即便有return，break，continue等改变执行流的语句，finally也会执行
• finally中的return 会覆盖 try 或者catch中的返回值
• finally中的异常会覆盖（消灭）前面try或者catch中的异常
• finally中的return会抑制（消灭）前面try或者catch块中的异常

注意：上面的3个例子都异于常人的编码思维，因此我建议：

• 不要在fianlly中使用return
• 不要在finally中抛出异常
• 减轻finally的任务，不要在finally中做一些其它的事情，finally块仅仅用来释放资源是最合适的
• 将尽量将所有的return写在函数的最后面，而不是try … catch … finally中

异常链

异常链化：以一个异常对象为参数构造新的异常对象。新的异常对象将包含先前异常的信息，这项技术主要是异常类的一个带Throwable参数的函数来实现的。这个当做参数的异常，我们叫它根源异常（cause）。顾名思义是将异常发生的原因一个传一个串起来，即把底层的异常信息传给上层，这样逐层抛出。

try {   
    lowLevelOp();   
} catch (LowLevelException le) {   
    throw (HighLevelException) new HighLevelException().initCause(le);   
}

当程序捕获到了一个底层异常，在处理部分选择了继续抛出一个更高级别的新异常给此方法的调用者。 这样异常的原因就会逐层传递。这样，位于高层的异常递归调用getCause()方法，就可以遍历各层的异常原因。 这就是Java异常链的原理。异常链的实际应用很少，发生异常时候逐层上抛不是个好注意， 上层拿到这些异常又能奈之何？而且异常逐层上抛会消耗大量资源， 因为要保存一个完整的异常链信息

自定义异常

如果要自定义异常类，则扩展Exception类即可，因此这样的自定义异常都属于检查异常（checked exception）。如果要自定义非检查异常，则扩展自RuntimeException。

按照国际惯例，自定义的异常应该总是包含如下的构造函数：

• 一个无参构造函数
• 一个带有String参数的构造函数，并传递给父类的构造函数。
• 一个带有String参数和Throwable参数，并都传递给父类构造函数
• 一个带有Throwable 参数的构造函数，并传递给父类的构造函数。

下面是IOException类的完整源代码，可以借鉴：

public class IOException extends Exception
{
    static final long serialVersionUID = 7818375828146090155L;
 
    public IOException()
    {
        super();
    }
 
    public IOException(String message)
    {
        super(message);
    }
 
    public IOException(String message, Throwable cause)
    {
        super(message, cause);
    }
 
    public IOException(Throwable cause)
    {
        super(cause);
    }
}

总结

---

---

面试题

1、try{} 里有一个 return 语句，那么紧跟在这个 try 后的 finally{} 里的 code 会不会被执行，什么时候被执行，在 return 前还是后?

答案：会执行，在方法返回调用者前执行。

注意：在finally中改变返回值的做法是不好的，因为如果存在finally代码块，try中的return语句不会立马返回调用者，而是记录下返回值待finally代码块执行完毕之后再向调用者返回其值，然后如果在finally中修改了返回值，就会返回修改后的值。显然，在finally中返回或者修改返回值会对程序造成很大的困扰，C#中直接用编译错误的方式来阻止程序员干这种龌龊的事情，Java中也可以通过提升编译器的语法检查级别来产生警告或错误，Eclipse中可以在如图所示的地方进行设置，强烈建议将此项设置为编译错误。

2、Java语言如何进行异常处理，关键字：throws、throw、try、catch、finally分别如何使用？

答：Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并可以对其进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果系统会抛出（throw）一个异常对象，可以通过它的类型来捕获（catch）它，或通过总是执行代码块（finally）来处理；try用来指定一块预防所有异常的程序；catch子句紧跟在try块后面，用来指定你想要捕获的异常的类型；throw语句用来明确地抛出一个异常；throws用来声明一个方法可能抛出的各种异常（当然声明异常时允许无病呻吟）；finally为确保一段代码不管发生什么异常状况都要被执行；try语句可以嵌套，每当遇到一个try语句，异常的结构就会被放入异常栈中，直到所有的try语句都完成。如果下一级的try语句没有对某种异常进行处理，异常栈就会执行出栈操作，直到遇到有处理这种异常的try语句或者最终将异常抛给JVM。

3、运行时异常与受检异常有何异同？ 

答：异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误，只要程序设计得没有问题通常就不会发生。受检异常跟程序运行的上下文环境有关，即使程序设计无误，仍然可能因使用的问题而引发。Java编译器要求方法必须声明抛出可能发生的受检异常，但是并不要求必须声明抛出未被捕获的运行时异常。异常和继承一样，是面向对象程序设计中经常被滥用的东西，在Effective Java中对异常的使用给出了以下指导原则： 
- 不要将异常处理用于正常的控制流（设计良好的API不应该强迫它的调用者为了正常的控制流而使用异常） 
- 对可以恢复的情况使用受检异常，对编程错误使用运行时异常 
- 避免不必要的使用受检异常（可以通过一些状态检测手段来避免异常的发生） 
- 优先使用标准的异常 
- 每个方法抛出的异常都要有文档 
- 保持异常的原子性 
- 不要在catch中忽略掉捕获到的异常

4、列出一些你常见的运行时异常？ 

答： 
- ArithmeticException（算术异常） 
- ClassCastException （类转换异常） 
- IllegalArgumentException （非法参数异常） 
- IndexOutOfBoundsException （下标越界异常） 
- NullPointerException （空指针异常） 
- SecurityException （安全异常）