Java第九章（异常处理）

        异常 ：指的是程序在执行过程中，出现的非正常情况，如果不处理最终会导致JVM的非正常停止。

一、Java异常体系

1.Throwable

        java.lang.Throwable类是java程序执行过程中发生的异常事件对应的类的根父类。

Throwable中的常用方法：

• public void printStackTrace()：打印异常的详细信息。

• printStackTrace。

• public String getMessage()：获取发生异常的原因。

2. Error 和 Exception

        Throwable可分为两类：Error和Exception。分别对应着java.lang.Error与java.lang.Exception两个类。

Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。

• 例如：StackOverflowError（栈内存溢出）和OutOfMemoryError（堆内存溢出，简称OOM）。

Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，需要使用针对性的代码进行处理，使程序继续运行。否则一旦发生异常，程序也会挂掉。例如：

• 空指针访问
• 试图读取不存在的文件
• 网络连接中断
• 数组角标越界

3.编译时异常和运行时异常

        Java程序的执行分为编译时过程和运行时过程。有的错误只有在运行时才会发生。

因此，根据异常可能出现的阶段，可以将异常分为

编译时期异常（即checked异常、受检异常）在执行javac.exe命令时，出现的异常。比如：

ClassNotFoundException

FileNotFoundException

IOException

运行时期异常（即runtime异常、unchecked异常、非受检异常）在执行java.exe命令时，出现的异常。

java.lang.RuntimeException:类及它的子类都是运行时异常。比如：

数组角标越界异常   ArrayIndexOutOfBoundsException
空指针异常         NullPointerException 
类型转换异常       ClassCastException
数字格式化异常     NumberFormatException
输入类型不匹配异常 InputMismatchException
算数异常          ArithmeticException

4.异常处理

方式一：try-catch-finally（可以嵌套使用）

Java提供了异常处理的抓抛模型。

        前面提到，Java程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出(throw)异常。

过程1：“抛”
 >"自动抛" ： 程序在执行的过程当中，一旦出现异常，就会在出现异常的代码处，自动生成对应异常类的对象，并将此对象抛出。

 >"手动抛" ：程序在执行的过程当中，不满足指定条件的情况下，我们主动的使用"throw + 异常类的对象"方式抛出异常对象。

过程2：“抓”
    狭义上讲：try-catch的方式捕获异常，并处理。
    广义上讲：把“抓”理解为“处理”。则此时对应着异常处理的两种方式：① try-catch-finally ② throws

• 如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。
• 如果一个异常回到main()方法，并且main()也不处理，则程序运行终止。

try{
...... //可能产生异常的代码
}
catch( 异常类型1 e ){
...... //当产生异常类型1型异常时的处置措施
}
catch( 异常类型2 e ){
......  //当产生异常类型2型异常时的处置措施
}  
finally{
...... //无论是否发生异常，都无条件执行的语句
} 

try

• 捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的业务逻辑代码放在try语句块中。
• try中声明的变量，出了try结构之后，就不可以进行调用了。

catch (Exceptiontype e)

• catch分支，分为两个部分，catch()中编写异常类型和异常参数名，{}中编写如果发生了这个异常，要做什么处理的代码。
• 如果明确知道产生的是何种异常，可以用该异常类作为catch的参数；也可以用其父类作为catch的参数。

• ArithmeticException类作为参数的地方，就可以用RuntimeException类作为参数，或者用所有异常的父类Exception类作为参数。但不能是与ArithmeticException类无关的异常，如NullPointerException（catch中的语句将不会执行）。

• 每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
• 如果有多个catch分支，并且多个异常类型有父子类关系，必须保证小的子异常类型在上，大的父异常类型在下。否则，报错。
• catch中常用异常处理的方式
  • public String getMessage()：获取异常的描述信息，返回字符串
  • public void printStackTrace()：打印异常的跟踪栈信息并输出到控制台。包含了异常的类型、异常的原因、还包括异常出现的位置，在开发和调试阶段，都得使用printStackTrace()。

finally使用及举例

  finally的理解

>我们将一定要被执行的代码声明在finally结构中

>更深刻的理解：无论try中或catch中是否存在仍未被处理的异常，无论try中或catch中是否存在return语句等，finally中声明的语句都一定要执行。

• 唯一的例外，使用 System.exit(0) 来终止当前正在运行的 Java 虚拟机。

• finally语句和catch语句是可选的，但finally不能单独使用。

什么样的代码我们一定要声明在finally中呢？

        >我们在开发中，有一些资源（比如：输入流、输出流、数据库连接、Socket连接等资源），在使用完以后，必须显示进行关闭操作，否则GC不会自动的回收这些资源，进而导致内存的泄露。为了保证这些资源在使用完以后，不管是否出现了未被处理的异常的情况下，这些资源能被关闭。我们必须将这些操作声明在finally中！

方式二：throws + 异常类型

如果在编写方法体的代码时，某句代码可能发生某个编译时异常，不处理编译不通过，但是在当前方法体中可能不适合处理或无法给出合理的处理方式，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。  从这个角度来看，throws的方式不算是真正意义上处理了异常。

声明抛出异常类型（throws）

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }

在throws后面可以写多个异常类型，用逗号隔开。举例：

public void readFile(String file)  throws FileNotFoundException,IOException {
	...
	// 读文件的操作可能产生FileNotFoundException或IOException类型的异常
	FileInputStream fis = new FileInputStream(file);
    //...
}

方法重写中throws的要求（针对于编译时异常来说）

• 如果父类被重写方法的方法签名后面没有 “throws 编译时异常类型”，那么重写方法时，方法签名后面也不能出现“throws 编译时异常类型”。
• 如果父类被重写方法的方法签名后面有 “throws  编译时异常类型”，那么重写方法时，throws的编译时异常类型必须 <= 被重写方法throws的编译时异常类型，或者不throws编译时异常。

        子类重写的方法抛出的异常类型可以与父类被重写的方法抛出的异常相同，或者是父类被重写的方法抛出的异常类型的子类。

• 方法重写，对于“throws 运行时异常类型”没有要求。

2.两种异常处理方式的选择

前提：对于异常，使用相应的处理方式。此时的异常，主要指的是编译时异常。

• 如果程序代码中，涉及到资源的调用（流、数据库连接、网络连接等），则必须考虑使用try-catch-finally来处理，保证不出现内存泄漏。
• 如果父类被重写的方法没有throws异常类型，则子类重写的方法中如果出现异常，只能考虑使用try-catch-finally进行处理，不能throws。
• 开发中，方法a中依次调用了方法b,c,d等方法，方法b,c,d之间是递进关系。此时，如果方法b,c,d中有异常，我们通常选择使用throws，而方法a中通常选择使用try-catch-finally。

3.手动抛出异常对象：throw

Java 中异常对象的生成有两种方式：

• 由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，那么针对当前代码，就会在后台自动创建一个对应异常类的实例对象并抛出。
• 由开发人员手动创建：new 异常类型([实参列表]);，如果创建好的异常对象不抛出，对程序没有任何影响，和创建一个普通对象一样。但是一旦throw抛出，就会对程序运行产生影响了。
• 为什么需要手动抛出异常对象？

在实际开发中，如果出现不满足具体场景的代码问题，我们就有必要手动抛出一个指定类型的异常对象。

throw语句会导致程序执行流程被改变，throw语句是明确抛出一个异常对象，因此它下面的代码将不会执行。

如果当前方法没有try...catch处理这个异常对象，throw语句就会代替return语句提前终止当前方法的执行，并返回一个异常对象给调用者。

总结：类比：上游排污，下游治污

4.自定义异常类

要继承一个异常类型

 自定义一个编译时异常类型：自定义类继承java.lang.Exception。

 自定义一个运行时异常类型：自定义类继承java.lang.RuntimeException。

（2）建议大家提供至少两个构造器，一个是无参构造，一个是(String message)构造器。

（3）自定义异常需要提供一个全局常量：static final long serialVersionUID

注意：

1. 自定义的异常只能通过throw抛出。
2. 自定义异常最重要的是异常类的名字和message属性。当异常出现时，可以根据名字判断异常类型。比如：TeamException("成员已满，无法添加");、 TeamException("该员工已是某团队成员");
3. 自定义异常对象只能手动抛出。抛出后由try..catch处理，也可以甩锅throws给调用者处理。

为什么需要自定义异常类？
        我们其实更关心的是，通过异常的名称就能直接判断此异常出现的原因。既然如此，我们就有必要在实际开发场景中，
        不满足我们指定的条件时，指明我们自己特有的异常类。通过此异常类的名称，就能判断出具体出现的问题。

 如果不使用try-catch，程序出现异常会如何？

对于当前方法来讲，如果不使用try-catch，则在出现异常对象以后会抛出throw此对象。如果没有处理方案，就会终止程序的执行。

如果执行finally代码块之前方法返回了结果或者jvm退出了，这时finally块中的代码还会执行吗?

会，除了：System.exit(0);

throw和throws的区别？

        角度1："形"，即使用的格式

        throw:使用在方法内部，“throw 异常类的对象”

        throws:使用在方法的声明处，"throws 异常类1,异常类2,..."

        角度2："角色"或作用不同。

                上游排污，下游治污。

        过程1：“抛”
            >throw
        过程2：“抓”
            > try-catch ; throws