Throwable类

概述

Throwable是java.lang包中一个专门用来处理异常的类。它有两个子类，即Error 和Exception，它们分别用来处理两组异常。

Error用来处理程序运行环境方面的异常，比如，虚拟机错误、装载错误和连接错误，这类异常主要是和硬件有关的，而不是由程序本身抛出的。

Exception是Throwable的一个主要子类。Exception下面还有子类，其中一部分子类分别对应于Java程序运行时常常遇到的各种异常的处理，其中包括隐式异常。比如，程序中除数为0引起的错误、数组下标越界错误等，这类异常也称为运行时异常RumtimeException，因为它们虽然是由程序本身引起的异常，但不是程序主动抛出的，而是在程序运行中产生的。Exception子类下面的另一部分子类对应于Java程序中的非运行时异常的处理，这些异常也称为显式异常非RumtimeException。它们都是在程序中用语句抛出、并且也是用语句进行捕获的，比如，文件没找到引起的异常、类没找到引起的异常等。

异常

1、概述

异常：就是程序出现了不正常的情况。

异常或者错误，都是以他们所在体系的父类作为后缀。

   XxxException  异常

   XxxError  错误

2、异常体系

3、Java虚拟机的默认处理异常的方式

      把异常的类名，原因，位置等信息显示在控制台。例如：

 public class Demo {
     public static void main(String[] args) {
         int[] arr = {1,2,3,4,5};
         System.out.println(arr[5]);
     }
 }

4、异常处理的方式（一）——捕获异常

有以下几种方式：

try{}...catch(异常类名 变量名){}

try{}...catch(异常类名 变量名){}...catch(异常类名 变量名){}

try{}...catch(异常类名 变量名){}...catch(异常类名 变量名){}...finally{}

try{}...finally{}

JDK1.7针对多个catch进行了优化：

try{}…catch(异常1 | 异常2 | 异常3….变量名){}…finally{}

需要注意：

try语句中的代码越少越好。

在多个catch语句中，需要将父异常放在最后面，否则将不会执行具体异常。

异常1、异常2都是平级关系的异常，若含有字符关系将报错。

 以后如果运行代码之后出现了异常,若不认识的异常，只需把报的异常类名直接复制到API当中，查看API中对这个类的描述，既可了解到出现问题的原因。

try、catch、finally的概述和作用

try：当觉得某些代码可能出现异常时，就将其放在try的大括号中；检测

catch：catch是捕获异常，当try中的代码出现异常时，且catch语句中含有该异常或该异常的父类的定义，那么该异常将被catch捕获，进行处理。

finally：finally语句中的代码一定会执行，通常用于资源关闭，数据库断开等释放资源的动作。特殊情况：当在执行finally语句前，退出了Java虚拟机，那么finally语句将不会被执行。

5、异常处理的方式（二）——声明异常

声明异常：在方法的大括号前用throws 异常类名

当在写方法时，如果觉得会出现异常，且自己没有解决或者想让调用者自己解决时，可以在方法的大括号前用throws异常类名，将可能会发生的异常声明出去。

 public static int method(int a, int b) throws Exception {
     int c = a / b;
     return c;
 }

6、异常处理的方式（三）——抛出异常

抛出异常：是在方法中用 throw 异常对象

 public static int method(int a, int b) {
     if (b==0) {
         throw new ArithmeticException();
     }
     int c = a / b;
     return c;
 }

7、自定义异常

A、如何自定义一个异常类?

让自定义类继承RuntimeException 或者继承Exception

注意：编译时期异常(非RuntimeException)，如果在方法内部用throw抛出了一个异常对象那么在方法声明上必须用throws关键字声明异常，运行时期异常就不需要这样。

 public class MyException extends Exception {
     public MyException(String message) {
         super(message);
     }
 }

8、（面试题）运行时期异常和编译时期异常的区别？

A：运行时期异常：

是不需要throws或try..catch处理的，只需要修改代码

B：编译时期异常：

需要处理的两种方式throws或try..catch

在开发中异常如果能够捕获最好要捕获处理。

9、（面试题）throw和throws的用法和区别?

A：throw

用法：用在方法内部，后面跟的是异常对象名称，抛出异常

区别：

用throw抛出了编译时期异常，方法上面必须用throws抛出。

用throw抛出了运行时期异常，方法上面可以不用throws抛出。

B：throws

用法：用在方法声明上，后面跟的是异常类名，声明异常

区别：用throws在方法上声明了异常，内部可以没有throw

10、（面试题）Exception和RuntimeException的区别?

A：Exception编译时期异常，必须处理的。

如果在方法上，throws了该类型的异常，将来调用者必须处理。

如果在方法内部，throw了该类型的异常，必须在方法上throws该异常。

B：RuntimeException运行时期异常，是不需要处理的。要改代码的。

如果在方法上，throws了该类型的异常，不需要处理。

如果在方法内部，throw了该类型的异常，方法上可以throws该异常，也可以不throws该异常。

11、（面试题）final，finally，finalize的区别。

final：是个关键字。

它修饰的类不能被继承；

它修饰的方法不能不重写；

它修饰的变量就变成了常量。

finally：是一个关键字。

是异常处理的一部分

一般用在捕获异常时,它里面的代码永远会被执行

(特殊情况在执行到finall之前就退出了虚拟机)

finalize() ：是Object类中垃圾回收的方法

 

12、（面试题）假如在catch里面有return语句，请问finally里面的代码还会执行吗?如果执行，是在return前，还是return后?

会执行。在return前执行。【准确答案:在return之间执行】

代码实现：

 public class Demo {
     public static void main(String[] args) {
         //测试c的值
         int c = method(10, 0);
         System.out.println("c = " + c); //20
     }

     public static int method(int a, int b) {
         int c = 10;
         try {
           //可能出现异常
             System.out.println(a / b);
         } catch (ArithmeticException e) {
           //打印异常信息
             e.printStackTrace();
             return 20;
         } finally {
             c = 30;
         }
         return c;
     }
 }

解释：

1.  当执行【e.printStackTrace();】完后，控制台出现异常提示，

2.  然后没有接着执行【return 20;】，而是跳转到finally语句，执行了【c = 30;】，

3.  然后才回去执行【return 20;】，

4.  所以最后打印c = 20

最后一题面试题的拓展

 public class Demo {
     public static void main(String[] args) {
         // 测试c的值
         int c = 10;
         c = method(10, 0);
         System.out.println("c = " + c); // 20
     }

     public static int method(int a, int b) {
         int c = 10;
         try {
           //可能出现异常
             System.out.println(a / b);
         } catch (ArithmeticException e) {
           //打印异常信息
             e.printStackTrace();
             return c = 20;
         } finally {
             c = 30;
             return c;
         }
     }
 }

解释：

1.  当执行【e.printStackTrace();】完后，控制台出现异常提示，

2.  然后没有接着执行【return = 20;】，而是跳转到finally语句，执行了【c = 30;】，

3.  因为finally语句中，有return语句，所以继续执行，返回30。

4.  最后回到主函数，而没有再回到catch语句的return语句，

5.  所以最后打印c = 30。