为什么要进行异常处理

下面这段代码能否正常执行

public class DemoCalc {
    public static void main(String[] args) {
        int a=0;
        int b=0;
        int c=a/b;
        System.out.println("运算结果为:"+c);
    }
}

结果是我们在控制台中看到一段错误提示，那是因为除数不能为0。异常就是在程序运行过程中发生的不正常事件，会中断运行的程序。

Java 使用了异常处理机制为程序提供了错误处理的能力，在程序中预先设置好对付异常的处理办法，待程序发生异常时对异常进行处理，处理完毕后，程序便可以继续运行。

下面来看一下Java中是如何进行异常处理的

如何进行异常处理

Java 的异常处理是通过5个关键字实现的：try、catch、finally、throw、throws

常见异常及异常分类

Throwable 是Java 中所有错误和异常的父类

Error类：Throwable的子类，仅靠程序本身无法恢复的严重的错误。

Exception类：Throwable的子类，由Java应用程序抛出和处理的非严重错误

RuntimeException类：Exception的子类，运行时异常，不要求程序必须做出处理。

Checked异常：Exception的子类，程序必须处理该类异常。

常见异常类型

try-catch

语法：

public void method(){
    try{
        //代码段1
        //可能产生异常的代码段
        //代码段2
    }catch(异常类型 ex){
        //对异常进行处理的代码段
    }
    //代码段
}

try-catch块捕获异常有三种情况：

1、try块中没有任何异常，try中正常，catch不会执行，正常执行try-catch后的代码。

2、try块中可能发生异常的代码段发生异常，代码段2不会执行，而是执行catch中异常处理的代码，正常执行try-catch后的代码。

catch中异常类型的printStackTrace() 方法能进行堆栈跟踪显示出程序运行到当前类的执行流程，异常堆栈信息中包含了异常的类型及异常出现的位置。

3、异常类型不匹配，程序将中断。比如try产生的异常为ArithmeticException，catch却用了 ClassCastException。

在控制台中接收数字做除法运算

import java.util.Scanner;

public class DemoInput {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        try{
            System.out.println("请输入被除数(整数)：");
            int a=input.nextInt();
            System.out.println("请输入除数(整数)：");
            int b=input.nextInt();
            int c=a/b;
            System.out.println("结果："+c);
        }catch(Exception ex) {
            ex.printStackTrace();
        }
        System.out.println("程序结束");
    }
}

try-catch-finally

语法：

public void method(){
    try{
        //可能会发生异常的代码
    }catch(异常类型 ex){
        //异常处理
    }finally{
        //无论如何都要执行的代码
    }
}

finally块：是否发生异常都执行

finllay块不执行的唯一情况：之前的代码中执行了 System.exit(1); 退出虚拟机

try-catch-finally的使用

import java.io.FileNotFoundException;
import java.util.Scanner;

public class DemoInput {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        try{
            System.out.println("请输入被除数(整数)：");
            int a=input.nextInt();
            System.out.println("请输入除数(整数)：");
            int b=input.nextInt();
            int c=a/b;
            System.out.println("结果："+c);
        }catch(Exception ex) {
            ex.printStackTrace();
        }finally {
            System.out.println("感谢您的使用");
        }
        System.out.println("程序结束");
    }
}

如果在try块或catch块中有return语句，finally是否还会执行？运行下面代码断点调试观察结果。

public class TestReturn {

    public static void main(String[] args) {
        try {
            int a=1+1;
            System.out.println("try执行");
            return;
        } catch (Exception e) {
            System.out.println("catch执行");
        }finally {
            System.out.println("finally执行");
        }
    }
}

try块或catch块中可以有return语句，如果有return语句会先执行finally最后再执行return。

多重catch

try块中可能会发生多种异常，如果要不同的异常进行不同的处理，需要使用多重catch进行处理。

语法：

public void method(){
    try{
        //可能发生异常的代码段
    }catch(异常类型1 e){
        //对异常类型1进行的处理的代码段
    }catch(异常类型2 e){
        //对异常类型2进行的处理的代码段
    }catch(异常类型n e){
        //对异常类型n进行的处理的代码段
    }
}

当try块中发生异常后，会逐个与catch中的异常类型进行匹配，匹配成功后，进入对应的catch进行异常处理，处理完成后不再进入其他catch，程序继续执行。

排列catch语句的顺序是：先子类后父类

发生异常时按顺序逐个匹配

只执行第一个与异常类型匹配的catch语句

将之前的代码 DemoInput.java 改造成多重catch

import java.io.FileNotFoundException;
import java.util.InputMismatchException;
import java.util.Scanner;

public class DemoInput {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        try{
            System.out.println("请输入被除数(整数)：");
            int a=input.nextInt();
            System.out.println("请输入除数(整数)：");
            int b=input.nextInt();
            int c=a/b;
            System.out.println("结果："+c);
        }catch(InputMismatchException e) {
            System.out.println("输入的数有误！");
        }catch(ArithmeticException e) {
            System.out.println("除数不能为0");
        }catch(Exception ex) {
            System.out.println("发生未知异常");
        }finally {
            System.out.println("感谢您的使用");
        }
        System.out.println("程序结束");
    }
}

声明异常 throws

如果一个方法体内抛出了异常如何通知调用者，可以在方法上声明异常。

public class TestThrows {
    
    //声明异常，多个异常可以用逗号隔开
    public void test()throws Exception,ClassNotFoundException{
        //可能会发生异常的代码
    }
}

处理方式一：调用者处理异常

public static void main(String[] args) {
    TestThrows t=new TestThrows();
    try {
        t.test();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

处理方式二：调用者继续声明异常

public static void main(String[] args) throws ClassNotFoundException, Exception {
    TestThrows t=new TestThrows();
    t.test();
}

main方法继续声明异常，调用者就变成虚拟机了，发生异常则按默认方式处理，打印出来。

抛出异常 throw

除了系统自动抛出的异常外，有些问题需要程序员自行抛出异常

public class TestThrow {
    public void inputAge(int age) throws Exception {
        if (age<1) {
            throw new Exception("还有这种年龄？");
        }
    }
    
    public static void main(String[] args) {
        TestThrow t=new TestThrow();
        try {
            t.inputAge(-1);
        } catch (Exception e) {
            System.out.println("年龄有误："+e.getMessage());
        }
    }
}

自行抛出异常后，还需要在方法上声明异常