try-catch-finally 异常处理的两种方式

异常处理

1. 明确什么是异常 （重点）

2. 能辨识出常见的异常及其含义。 （熟悉+）

3. 理解异常产生的原理 （了解）

4. 能处理异常 （重点）

5. 能够自定义异常类型 （熟悉）

目的

我们发现异常，捕获异常的目的是要对异常进行补救，而不是打印一下。

什么是异常？

异常是在程序中导致程序中断运行的一种指令流。

例如，现在有如下的操作代码：

public class ExceptionDemo01{
public static void main(String argsp[]){
int i = 10 ;
int j = 0 ;
System.out.println("============= 计算开始 =============") ;
int temp = i / j ; // 进行除法运算
System.out.println("temp = " + temp) ;
System.out.println("============= 计算结束 =============") ;
}
};
运行结果：
============= 计算开始 =============
Exception in thread "main" java.lang.ArithmeticException: / by zero
at ExceptionDemo01.main(ExceptionDemo01.java:6)

以上的代码在“int temp = i / j ;”位置处产生了异常，一旦产生异常之后，异常之后的语句将不再执行了，所以现 在的程序并没有正确的执行完毕之后就退出了。

那么，为了保证程序出现异常之后仍然可以正确的执行完毕，所以要采用异常的处理机制。

处理异常

异常处理一般有两种方式，1.使用catch捕获异常； 2.使用throws关键字在方法声明时抛出异常

1.catch捕获异常

如果要想对异常进行处理，则必须采用标准的处理格式，处理格式语法如下：

try{

      // 有可能发生异常的代码段

}catch(异常类型1 对象名1){

      // 异常的处理操作  异常补救

}catch(异常类型2 对象名2){

     // 异常的处理操作   异常补救

} ...

finally{

     // 异常的统一出口

       System.out.println("这里的代码无论是否出现异常都会执行，一般用于资源回收");

}

在进行异常的处理之后，在异常的处理格式中还有一个finally语句，那么此语句将作为异常的统一出口，不管是否产生 了异常，最终都要执行此段代码。

无论异常是否发生，finally必然执行。读取文件，占用文件，读取数据库等，都在finally中释放，因为finally必然执行。一般用于资源回收。

try+catch的处理流程

1、 一旦产生异常，则系统会自动产生一个异常类的实例化对象。

2、 那么，此时如果异常发生在try语句，则会自动找到匹配的catch语句执行，如果没有在try语句中，则会将异 常抛出.

3、 所有的catch根据方法的参数匹配异常类的实例化对象，如果匹配成功，则表示由此catch进行处理。

2.throws  throw 抛出异常

在程序中异常的基本处理已经掌握了，但是随异常一起的还有一个称为throws关键字，此关键字主要在方法的声明上使 用，表示方法中不处理异常，而交给调用处处理。

1.throws是函数方法抛出异常，一般写在方法的头部，用来抛出一些异常，本身不进行解决，抛给方法的调用者进行解决(try catch)

格式： 返回值 方法名称()throws Exception{ }

Integer类： public static int parseInt(String text)throws NumberFormatException

2.throw是语句抛出异常，出现于函数内部，用来抛出一个具体异常实例，throw被执行后面的语句不起作用，直接转入异常处理阶段

一般是用户自定义的RuntimeException运行时异常，然后使用throw抛出。

public class Demo9 {
    public static void main(String[] args) {
    }

    /**
     * 异常是否抛出去, 应该站在哪个角度思考?
     *
     *  如果是因为传参导致异常 , 应该通过throws将异常抛出去.
     *
     * @param text
     * @throws IOException : 因为传递的指令不对, 会导致此问题发生(s2=0时)
     */
    public static void shutdown(String text) throws IOException {
        Runtime.getRuntime().exec(text);
    }
    /**
     * 此方法用于求两个参数的和
     *  会将两个参数 转换为数字 求和
     * @param s1  字符串参数1
     * @param s2  字符串参数2
     */
    public static void sum(String s1,String s2){
        int sum = Integer.parseInt(s1)+Integer.parseInt(s2);
        System.out.println("和是:"+sum);
    }
}

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<0 || age>180){
            RuntimeException e = new RuntimeException("年龄不合理");
            throw e;
        }else{
            this.age = age;
        }

    }
}

异常体系结构

异常指的是Exception ， Exception类， 在Java中存在一个父类Throwable（可能的抛出）

Throwable存在两个子类：

1.Error：表示的是错误，是JVM发出的错误操作,只能尽量避免，无法用代码处理。

2.Exception：一般表示所有程序中的错误，所以一般在程序中将进行try…catch的处理。

RuntimeExcepion与Exception的区别

RuntimeException是Exception的子类，

catch(Exception e) 就是范围最大的捕获异常。如果为了方便，则可以将所有的异常都使用Exception进行捕获。

所有RuntimeException的子类即为非检查型异常；Exception的其余子类都为检查型异常。所谓“检查型异常”是指在源代码例必须显式地进行捕获处理，eclipse和idea都是自动编译的，当我们把代码写完的时候，如果有红线提示或者错误提示，那么就是检查异常。也就是说，当你看到某个方法声明中可能抛出某个检查型异常，那么作为调用方必须考虑如何处理这个异常，否则编译器就是给出错误提示。

所谓“非检查型异常”，也就是运行时异常，编译的时候不会给错误提示，运行的时候有可能出现异常。如： 用户输入0作为除数，就会 出现异常。通常是可以通过编码加以避免的逻辑错误，具体根据需要来判断是否需要捕获，并不会在编译期强制要求。例如NullPointerException、ArrayIndexOutOfBoundsException等。也就是说，程序员应该通过合理编码来努力避免程序出现这类异常，或者说程序出现这类异常就是程序员的责任。

异常处理常见面试题

1. try-catch-finally 中哪个部分可以省略？

答： catch和finally可以省略其中一个 ， catch和finally不能同时省略 注意:格式上允许省略catch块, 但是发生异常时就不会捕获异常了,我们在开发中也不会这样去写代码.

2. try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？

答：finally中的代码会执行 详解：

执行流程：

1. 先计算返回值， 并将返回值存储起来， 等待返回

2. 执行finally代码块

3. 将之前存储的返回值， 返回出去；

需注意：

1. 返回值是在finally运算之前就确定了，并且缓存了，不管finally对该值做任何的改变，返回的值都不 会改变

2. finally代码中不建议包含return，因为程序会在上述的流程中提前退出，也就是说返回的值不是try或 catch中的值

3. 如果在try或catch中停止了JVM,则finally不会执行.例如停电- -, 或通过如下代码退出 JVM:System.exit(0)。

try中有return时，finally也会执行，这个return值在finally执行之前的try中已经准备好了，复制备份放入了缓存。如果return返回的是基本数据类型，如int，那么finally中再给int赋值也不会改变return返回的值。如果return返回的是一个对象，那么复制到缓存中的是这个对象的地址，这时在finally中改变这个对象的值时，返回的值就是改变以后的值。

public class Demo7 {
    public static void main(String[] args) {
        int a = haha();
        System.out.println(a);
    }
    public static int haha(){
        int a = 10;
        try{
            return a;
        }catch(Exception e){

        }finally {
            a = 20;
        }
        return 0;
    }
    static class Person{
        int age;
    }
}

以上输出结果是：10

因为finally执行之前，retrun 的a是10，这个值已经复制到缓存中，输出时，就i时输出缓存中的值。finally再改变a的值也不会被输出。

public class Demo6 {
    public static void main(String[] args) {
        Person p = haha();
        System.out.println(p.age);
    }
    public static Person haha(){
        Person p = new Person();
        try{
            p.age = 18;
            return p;
        }catch(Exception e){
            return null;
        }finally {
            p.age = 28;
        }
    }
    static class Person{
        int age;
    }
}

以上输出结果是：28

try中return的p对象，放到输出缓存中是P对象的地址。finally中改变的是这个地址中的值，所以输出的值就是改变之后的值。