十、Java异常

一、异常简介

二、异常体系图

• 根类：Throwable
  

三、常见的异常

3.1 常见的运行时异常

3.2 常见的编译异常

四、异常处理

4.1 异常处理的方式

• 方式一：try{…}catch(){…}finally{…}

try{
代码/可能有异常
}catch(Exception e){
// 捕获到异常
// 1. 当异常发生时
// 2. 系统将异常封装成 Exception 对象 e，传递给catch
// 3. 得到异常对象后，程序员自己处理
}finally{
// 1. 不管try代码块是否有异常发生，始终要执行finally
// 2. 所以，通常将释放资源的代码，放在finally中
}

• 方式二：throws
  

4.2 try-catch异常处理

4.2.1 try-catch异常处理基本语法

4.2.2 try-catch异常处理的注意细节

package com.throwable_;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Exception02 {
    public static void main(String[] args) {
        // 1. 如果try代码块有可能有多个异常
        // 2. 可以使用多个catch分别捕获不同的异常，相应处理
        // 3. 要求子类异常在前面，父类异常写在后面

        try {
            Person p = new Person();
            p = null;
            System.out.println(p.name);
            int n1 = 10;
            int n2 = 0;
            System.out.println(n1 / n2);

        } catch (ArithmeticException e) {
            System.out.println("算数异常：" + e.getMessage());
        } catch (NullPointerException e) {
            System.out.println("空指针异常" + e.getMessage());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {

        }
        System.out.println("程序继续执行");
    }
}

class Person {
    String name;

    public String getName() {
        return name;
    }

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

4.3 throws异常处理

4.3.1 throws异常处理基本介绍

public class Throws01{
    public void f2 throws FileNotFoundException,NullPointerException(){
        // 创建了一个文件流对象
        // 解读：
        // 1. 这里的异常是一个 FileNotFoundException 编译异常
        // 2. 使用前面讲过的 try-catch-finally
        // 3. 使用throws，抛出异常，让调用f2方法的调用者（方法）进行处理
        // 4. throws 后面的异常类型可以是方法中产生的异常类型，也可以是它的父类
        // 5. throws 关键字后也可以是 异常列表，即可以抛出多个异常
        FileInputStream fis = new FileInputStream('....')
    }
}

4.3.2 throws注意事项和使用细节

五、自定义异常

5.1 自定义异常基本概念

5.2 自定义异常的步骤

public class CustomException{
    public static void  main(String[] args){
        int age = 180;
        // 要求范围在: 18 - 120 之间，否则抛出一个自定义异常
        if(!(age >= 18 && age <= 180)){
            throw new AgeException("年龄需要在 18~120 之间");
        }
        System.out.println("你的年龄范围正确");
    }

}

// 自定义一个异常
// 解读
// 1. 一般情况下，我们自定义异常是继承 RuntimeException
// 2. 即把自定义异常做成 运行时异常，好处是，我们可以使用默认的处理机制
class AgeException extends RuntimeException{
    public AgeException(String message){
        super("message");
    }
}

六、throw和throws的对比

七、细节

7.1 异常分类

• 异常
  1. 错误
  2. Exception
     1. 运行时异常
     2. 编译时异常

7.2 try-catch-finally与return的使用逻辑

https://www.cnblogs.com/sunshineweb/p/7656463.html try catch finally 中包含return的几种情况，及返回结果

7.2.1 在try和catch中有return，finally中没有return

public class Test {
    public static int num=1;
    public static void main(String[] args) throws ParseException {
        int result;
        result = num();
        System.out.println(result);
    }
    private static int num() {
        try{
            int b=4/0;
            return num = num+2;
        }catch(Exception e){
            return num = num+3;
        }finally {
        System.out.println("不管你怎么样，我都是要执行");    
        }        
    }    
}

/*
输出内容为： 
不管你怎么样，我都是要执行 
4
*/
// 原因，int b=4/0;发生了异常，直接进入catch的代码块中执行了return num = num+3;此时把返回的结果4。如果没有异常的话会执行try中的return，catch中的代码不会执行，但是无论怎样，finally中的代码都会执行。

7.2.2 在try和catch中有return，finally中没有return

要返回的数据是基本数据类型还是引用数据类型，对结果也有不同的影响

• 返回的数据为基本数据类型，则finally中对要返回数据操作无影响

public class Test {
    public static int num=1;
    public static void main(String[] args){
        int result;
        result = num();
        System.out.println(result);//结果不受finally影响，输出4
        System.out.println(num);//5
    }
    private static int num() {
        try{
            int b=4/0;
            return num = num+2;
        }catch(Exception e){
            return num = num+3;
        }finally {
            ++num;
        }        
    }    
}
// result的值为4的原因是，当执行到catch中的 return num = num+3;时，已经把要返回的num的值存到了其他局部变量中，在执行完finally中的++num;后，是从其他局部变量中获取的返回值，而不是直接返回num的值

• 返回的数据为引用数据类型，finally中如果改变了返回对象的属性则影响结果，如果改变的是对象的引用则和基本数据类型一样不改变结果

public class Test {
    public static void main(String[] args) {
        People bride;
        bride = marry();
        System.out.println(bride.getState());//结果受finally影响，输出dead
    }
    private static People marry() {
        People people=new People();
        people.setState("happy");;
        try{
            int b=4/0;
            return people;
        }catch(Exception e){
            return people;
        }finally {
            people.setState("dead");
        }        
    }    
}
// bride.getState()的结果为dead的原因是，当执行到catch中的return  people;时，把要返回people的内存地址存储起来，但是finally中对该内存地址对象的属性进行了更改，bride = marry(); 获取的内存地址对应的对象是更改属性后的people，所以属性值改变了。

7.2.3 在try和catch中有return，finally中也有return

• try或catch中return后面的代码会执行，但最终返回的结果为finally中return的值，需要注意的是try或catch中return后面的代码会执行，只是存起来了，并没有返回，让finally捷足先登先返回了

public class Test {
    public static int num=1;
    public static void main(String[] args) throws ParseException {
        int result;
        result = num();
        System.out.println(result);//输出结果为1003
        System.out.println(num);//输出结果为1001
    }
    private static int num() {
        try{
            int b=4/0;
            return num = num+1000;
        }catch(Exception e){
            return num = num+1000;
        }finally {
            return num+2;
        }        
    }    
}

7.2.4 在try中有return，在catch中新抛出异常，finally中有return

• 如果catch块中捕获了异常, 并且在catch块中将该异常throw给上级调用者进行处理, 但finally中有return, 那么catch块中的throw就失效了, 上级方法调用者是捕获不到异常

public class Test {
    public static void main(String[] args) throws Exception {
        String result="";
        try {
            result = num();
        } catch (Exception e) {
            System.out.println("青天大老爷在此");
        }
        System.out.println(result);
    }
    public static String num() throws Exception {
        try{
            int b=4/0;
            return "总是异常，反正我又不会执行";
        }catch(Exception e){
            throw new Exception();
        }finally {
            return "用金钱蒙蔽你的双眼";
        }    
    }    
}

/*
用金钱蒙蔽你的双眼  
如果把finally里的return注释掉就会输出：
青天大老爷在此
*/

7.3 对于 编译时 与 运行时异常的 处理机制

• 注意：对于 编译时 异常，必须由编写者手动处理；而对于 运行时 异常默认被自动 throws 抛出，由上一级调用者(方法)处理