Java异常处理机制

Java异常处理机制

一、异常概述与异常体系结构

1.异常概述

程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常（开发过程中的语法错误和逻辑错误不是异常）。
Java程序在执行过程中所发生的异常事件可分为两类：
Error：Java虚拟机无法解决的严重问题。
Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。
**异常存在的形式：**异常在java中以类的形式存在，每一个类都可以创建异常对象。

2.异常体系结构

Java标准库内建了一些通用的异常类，这些类以Throwable为顶层父类。 Throwable又派生出Error类和Exception类。
Error和Exception的区别:
Error类错误是系统中的错误，所有错误只要发生，Java程序只有一个结果那就是终止程序的执行。退出JVM，错误是不能处理的；
Exception错误表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。
Exception异常划分：
编译时异常：
是RuntimeException以外的异常，编译时异常表示必须在编写程序的时候预先对这种异常进行处理，如果不处理编译器报错。
运行时异常：
运行时异常在编写程序阶段，是RuntimeException类及其子类异常，你可以选择处理，也可以选择不处理。运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

二、异常处理机制

Java采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁、优雅，并易于维护。
异常的抛出机制:
如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。如果一个异常回到main()方法，并且main()也不处理，则程序运行终止。

1.异常处理机制一：try-catch-finally

使用try…catch语句进行异常捕捉。在Java中，异常处理的任务就是将执行控制流从异常发生的地方转移到能够处理这种异常的地方去。也就是说：当一个函数的某条语句发生异常时，这条语句的后面的语句不会再执行，它失去了焦点。执行流跳转到最近的匹配的异常处理catch代码块去执行，异常被处理完后，执行流会接着在“处理了这个异常的catch代码块”后面接着执行。

package com.wenjian.javase.exception;

public class ExceptionTest01 {
    //利用try...catch进行捕捉
    public static void main(String[] args) {
        try {
            doSome();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static void doSome() throws ClassNotFoundException{
        System.out.println("doSome!!!!");
    }
}

语法格式：

/**
 * 	语法格式：
 *         try{
 *             ...... //可能产生异常的代码
 *         }
 *         catch( ExceptionName1 e ){
 *             ...... //当产生ExceptionName1型异常时的处置措施
 *         }
 *         catch( ExceptionName2 e ){
 *             ...... //当产生ExceptionName2型异常时的处置措施
 *         }
 *         [ finally{
 *             ...... //无论是否发生异常，都无条件执行的语句
 *         } ]
 *
 * 	语法解释：
 * 		try：
 * 			捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中。
 * 			如果发生异常，则尝试去匹配catch块，catch块可以有多个（因为try块可以出现多个不同类型异常）;
 * 			如果执行完try不管有没有发生异常，则接着去执行finally块和finally后面的代码（如果有的话）。
 * 			
 * 		catch (Exceptiontype e)：
 * 			在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
 * 			每一个catch块用于捕获并处理一个特定的异常，或者这异常类型的子类。
 * 			Java可以将多个异常声明在一个catch中。catch(Exception1 | Exception2 | Exception3 e)
 * 			catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的，则虚拟机将使用这个catch块来处理异常。
 * 			在catch块中可以使用这个块的异常参数来获取异常的相关信息。异常参数是这个catch块中的局部变量，其它块不能访问。
 *
 * 		finally：
 * 			finally块通常是可选的。捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，
 * 			使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。
 * 			不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，
 * 			finally块中的语句都会被执行。
 * 			一个try至少要有一个catch块，否则， 至少要有1个finally块。
 * 			但是finally不是用来处理异常的，finally不会捕获异常。
 * 			finally主要做一些清理工作，如流的关闭，数据库连接的关闭等。
 */

注意：
1.catch后面的小括号中的类型可以是具体的异常类型，也可以是该异常类型的父类型。

        //IOException是FileNotFoundException的父类
        try{
            FileInputStream fis = new FileInputStream("E:\\节点\\MyBatis\\节点-MyBatis讲义.pdf");
        }catch(IOException e){ //多态：IOException e = new FileNotFoundException();
            System.out.println("文件不存在");
        }
        System.out.println("成功找到文件");
    }

2.catch可以写多个。建议catch的时候，精确到一个一个处理。这样有利于程序的调试。
3.catch写多个的时候，从上到下，必须遵守从小到大；即FileNotFoundException < IOException。

        try{
            //创建输入流
            FileInputStream fis = new FileInputStream("E:\\节点\\MyBatis\\节点-MyBatis讲义.pdf");
            //读文件
            fis.read();
        }catch(FileNotFoundException e){ //多态：IOException e = new FileNotFoundException();
            System.out.println("文件不存在");
        }catch(IOException e){
            System.out.println("读文件报错了");
        }
        
        System.out.println("成功找到文件");
    }

2.异常处理机制二：throws

throws仅仅是将函数中可能出现的异常向调用者声明，而自己则不具体处理。在方发声明的位置上，使用throws关键字，抛给上一级；谁调用我，我就抛给谁。处理异常的态度：上报。

package com.wenjian.javase.exception;

public class ExceptionTest01 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 第二种处理方式： 在方法声明的位置上继续使用：throws，来完成异常的上抛。抛给调用者。
        doSome();

    }
    public static void doSome() throws ClassNotFoundException{
        System.out.println("doSome!!!!");
    }
}

3.两种机制总结：

	异常处理机制的作用就是增强程序的健壮性。一般不建议在main方法上使用throws，因为这个异常如果真的发生了，一定会抛给JVM。JVM只有终止。如果想要异常发生了也不影响程序的执行，一般在main方法中使用try...catch进行捕捉。main就不继续往上抛了。

package com.wenjian.javase.exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ExceptionTest02 {
    //一般不建议在main方法上使用throws，因为这个异常如果真的发生了，一定会抛给JVM。JVM只有终止。
    //异常处理机制的作用就是增强程序的健壮性。
    //如果想要异常发生了也不影响程序的执行，一般在main方法中使用try...catch进行捕捉。main就不继续往上抛了。
    /*public static void main(String[] args) throws FileNotFoundException {
        System.out.println("main begin");
        m1();
        System.out.println("main over");
    }*/
    public static void main(String[] args){
        System.out.println("main begin");
        try {
            //try尝试
            m1();
        } catch (FileNotFoundException e) {
            //catch是捕捉异常之后走的分支。
            System.out.println("文件不存在，可能路径错误，也可能该文件被删除了");
        }
        System.out.println("main over");
    }

    private static void m1() throws FileNotFoundException {
        System.out.println("m1 begin");
        m2();
        System.out.println("m1 over");
    }

    private static void m2() throws FileNotFoundException {
        System.out.println(("m2 begin"));
        m3();
        System.out.println("m2 over");
    }

    private static void m3() throws FileNotFoundException {
        //调用SUN jdk中某个构造方法
        /*
        * 编译报错的原因：
        *   第一：这里调用了一个构造方法：FileInputStream(String name)；
        *   第二：这个构造方法的声明位置上有throws FileNotFoundException；
        *   第三：通过类的继承结构看到：FileNotFoundException父类是IOException,IOException的父类是Exception,
        *   最终得知，FileNotFoundException是编译时异常。*/
//        new FileInputStream("E:\\节点\\MyBatis");
        new FileInputStream("E:\\节点\\MyBatis\\节点-MyBatis讲义.pdf");

    }
}

注意：
只要异常没有捕捉，采用上报的方式，此方法的后续代码不会执行。另外，try语句块中的某一行出现异常，该行后面的代码不会执行。try…catch捕捉异常之后，后续代码可以执行。

//语法格式：
    public static void main(String[] args){
        System.out.println("main begin");
        try {
            //try尝试
            m1(); //可能产生的异常
            //以上代码出现异常，直接进入catch语句块中执行
            System.out.println("出现异常代码不会执行");
        } catch (FileNotFoundException e) {
            //catch是捕捉异常之后走的分支；当产生异常之后的处置措施。
            System.out.println("产生异常之后的处置措施");
        }
        //try..catch捕捉异常之后，后续代码可以执行。
        System.out.println("后续代码可以继续执行");
    }

4.两种异常对象常用方法：

获取异常简单的描述信息：获取异常信息，返回字符串。

String msg = exception.getMessage();

打印异常堆栈信息：获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

//帮助我们查看异常信息
e.printStackTrace();