什么是异常？如何处理异常？

问题引入

1、编写代码如下：

2、运行测试


3、新手误区：

• 容易想当然：认为所有用户都会按照程序员的思路来操作；
• 容易**“我认为”**：用户的需求或设计在别人看来就是合理的，程序员不是产品经理，不要擅自改动；

4、异常产生的过程

所以x/y这里变成了一个new的操作


5、为了避免JVM接收到异常对象，可以选择在 创建异常对象——>虚拟机 过程中拦截，这就引入了处理异常。

一、异常的概念

什么是异常呢？

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

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

比如说，你的代码少了一个分号，那么运行出来结果是提示是错误java.lang.Error ；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出java.lang.ArithmeticException 的异常。

异常发生的原因有很多，通常包含以下几大类：

• 用户输入了非法数据。
• 要打开的文件不存在。
• 网络通信时连接中断，或者JVM内存溢出。

这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。

要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：

• 检查性异常： 最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
• 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
• **错误：**错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

通过代码来理解：

public class Demo_1 {
    
    
    public static void main(String[] args) {
    
    
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int x = input.nextInt();
        System.out.println("请再输入一个数字");
        int y = input.nextInt();
        System.out.println(x / y);
        System.out.println("运行完毕！");
    }
}

运行结果：
（1）
（2）

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

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

二、异常的体系结构

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

• 1.Error：表示的是错误，是JVM发出的错误操作,只能尽量避免，无法用代码处理。（比如内存过小）

• 2.Exception：一般表示所有程序中的错误，所以一般在程序中将进行try…catch的处理。
  
  下面将详细讲述这些异常之间的区别与联系：

• Error：Error类对象由 Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。例如，Java虚拟机运行错误（Virtual
  MachineError），当JVM不再有继续执行操作所需的内存资源时，将出现
  OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止；还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之
  外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在Java中，错误通常是使用Error的子类描述。

• Exception：在Exception分支中有一个重要的子类RuntimeException（运行时异常），该类型的异常自动为你所编写的程序定义ArrayIndexOutOfBoundsException（数组下标越界）、NullPointerException（空指针异常）、ArithmeticException（算术异常）、MissingResourceException（丢失资源）、ClassNotFoundException（找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生；而RuntimeException之外的异常我们统称为非运行时异常，类型上属于Exception类及其子类，从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

注意
Error和Exception的区别：
（1）Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；
（2）Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

2、多异常捕获的注意点：

• 1、 捕获更粗的异常不能放在捕获更细的异常之前。
• 2、 如果为了方便，则可以将所有的异常都使用Exception进行捕获。

3、RuntimeException：运行时异常（非受检异常）。参数有可能引发错误时，发出的异常不会有提示，就直接崩溃。

• 受检异常：在正确的程序运行过程中，很容易出现的、情理可容的异常状况，在一定程度上这种异常的发生是可以预测的，并且一旦发生该种异常，就必须采取某种方式进行处理。

提示
除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受检异常，当程序中可能出现这类异常，要么使用try-catch语句 进行捕获，要么用throws子句 抛出，否则编译无法通过。

• 非受检异常：包括RuntimeException及其子类和Error。

提示
非受检异常为编译器不要求强制处理的异常，受检异常则是编译器要求必须处置的异常。

三、异常处理的基本语法

（一）try - catch

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

处理格式

try{
    
    
    // 有可能发生异常的代码段 
}catch(异常类型1 对象名1){
    
     
    // 异常的处理操作 
}catch(异常类型2 对象名2){
    
    
    // 异常的处理操作 } ... 
finally{
    
     
    // 异常的统一出口 
}

注意啦：

在进行异常的处理之后，在异常的处理格式中还有一个finally语句，那么此语句将作为异常的统一出口，不管是否产生了异常，最终都要执行此段代码。（finally不执行情况：电脑没电、关机、软件关闭、程序从内存中消失、finally之前出现exit退出。其余情况finally都会执行）

try+catch的处理流程

• 1、 一旦产生异常，则系统会自动产生一个异常类的实例化对象。
• 2、 那么，此时如果异常发生在try语句，则会自动找到匹配的catch语句执行，如果没有在try语句中，则会将异常抛出（中断）.
• 3、 所有的catch根据方法的参数匹配异常类的实例化对象，如果匹配成功，则表示由此catch进行处理。
  

使用异常的效果：

1、不捕获异常：

2、捕获异常

处理多异常的格式 1

import java.util.InputMismatchException;
import java.util.Scanner;

/**
 * 处理多异常的格式 1
 */
public class Demo_2 {
    
    
    public static void main(String[] args){
    
    
        haha();
        System.out.println("程序执行完毕 , 正常结束");
    }

    private static void haha() {
    
    
        try {
    
    
            Scanner input = new Scanner(System.in);
            System.out.println("请数字输入一个");
            int x = input.nextInt();
            System.out.println("请再输入一个数字");
            int y = input.nextInt();
            System.out.println(x / y);
            System.out.println("处理完毕");
        }catch(InputMismatchException e){
    
     //具体到将会发生怎么类型的异常
            System.out.println("必须输入数字啊, 帅哥");
        }catch(ArithmeticException e){
    
    
            System.out.println("除数不能为0啊 , 帅哥");
        }
    }
}

运行结果：

处理多异常的格式 2（了解）

（将异常合并起来，了解即可）

import java.util.InputMismatchException;
import java.util.Scanner;

/**
 * 处理多异常的格式 2   了解
 */
public class Demo_3 {
    
    
    public static void main(String[] args){
    
    

        haha();
        System.out.println("程序执行完毕 , 正常结束");
    }

    private static void haha() {
    
    
        try {
    
    
            Scanner input = new Scanner(System.in);
            System.out.println("请输入一个数字");
            int x = input.nextInt();
            System.out.println("请再输入一个数字");
            int y = input.nextInt();
            System.out.println(x / y);
            System.out.println("处理完毕");
        }catch(InputMismatchException | ArithmeticException e){
    
    
            System.out.println("输入有误");
        }
    }
}

运行结果：

处理多异常的格式 3（常用）

import java.util.Scanner;

/**
 * 处理多异常的格式 3    常用
 */
public class Demo_4 {
    
    
    public static void main(String[] args){
    
    
        haha();
        System.out.println("程序执行完毕 , 正常结束");
    }

    private static void haha() {
    
    
        try {
    
    
            Scanner input = new Scanner(System.in);
            System.out.println("请输入一个数字");
            int x = input.nextInt();
            System.out.println("请再输入一个数字");
            int y = input.nextInt();
            System.out.println(x / y);
            System.out.println("处理完毕");
        }catch(Exception e){
    
    //多态 不管什么类型异常，都用Exception类。
            System.out.println("输入有误");
        }finally {
    
    
            //必然执行的异常统一处理出口
            //无论是否发生异常, finally必然执行.
            System.out.println("213123");
        }
    }
}

运行结果：

小结

被捕获异常后进行处理，程序会继续向下正常执行，而不会返回给main的调用者JVM中中断运行。

finally常见面试问题

考点：finally语句必然执行 和 return返回值的情况

1.finally在某种情况下是否会执行呢？

答：finally不执行情况：电脑没电、关机、软件关闭、程序从内存中消失、finally之前出现exit退出。其余情况finally都会执行

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

答： catch和finally可以省略其中一个 ， catch和finally不能同时省略

注意:格式上允许省略catch块, 但是发生异常时就不会捕获异常了,我们在开发中也不会这样去写代码。

问题：try-catch-finally 中，如果 catch 中有 return 了，finally 还会执行吗？

答：finally中的代码会执行

详解：执行流程：

• 1.先计算返回值， 并将返回值存储起来， 等待返回；
• 2.执行finally代码块；
• 3.将之前存储的返回值， 返回出去。

需注意：

• 返回值是在finally运算之前就确定了，并且缓存了，不管finally对该值（非引用数据类型）做任何的改变，返回的值都不会改变
• finally代码中不建议包含return，因为程序会在上述的流程中提前退出，也就是说返回的值不是try或 catch中的值
• 如果在try或catch中停止了JVM,则finally不会执行.例如停电…, 或通过如下代码退出 JVM:System.exit(0);

finally举例1：（即使return，在准备返回值与跳出函数之间，仍会执行finally中的语句）
代码：
运行结果：

finally举例2：（引用数据类型和非引用数据类型的区别）
代码：（引用数据类型）

运行结果：

从结果可看出：由于 返回值是引用数据类型
，在return之前准备好p（将引用地址进行备份），但是finally中通过引用数据类型的地址，修改了具体的值，所以还是显示的最终结果会更改属性值为28；

内存分析：

代码：（非引用数据类型） 及 运行结果：

内存分析：

finally举例3 ：exit（）退出[表明终止后面的代码]，不执行finally
这部分代码因为除数不能为0，所以会抛出异常，进入到catch{}里面，在catch里面有一行代码 System.exit(0); 这一行代码的意思就是强制退出程序，因此finally不会执行

• 退出代码：System.exit( 0）可以输入0.1.2.3 0表示正常退出 剩下是非正常退出。

我之前也写了一篇有关 关于 finally 常考的面试题 感兴趣的伙伴们可以点击阅读哟！

（二）throws

1.throws 概念

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

如果一个方法可以导致一个异常但不处理它，它必须指定这种行为以使方法的调用者可以保护它们自己而不发生异常。要做到这点，我们可以在方法声明中包含一个throws子句。一个throws子句列举了一个方法可能引发的所有异常类型。这对于除了Error或RuntimeException及它们子类以外类型的所有异常是必要的。一个方法可以引发的所有其他类型的异常必须在throws子句中声明，否则会导致编译错误。

格式

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

IDEA的快捷小技巧之一：若代码标红提示，想查看具体什么问题，则在标红后按住alt + 回车（enter）。

2.案例

Exception 是该方法可能引发的所有的异常,也可以是异常列表，中间以逗号隔开。
例如：

class TestThrows{
    
    
    static void throw1(){
    
    
        System.out.println("Inside throw1 . ");
        throw new IllegalAccessException("demo");
    }
    public static void main(String[] args){
    
    
        throw1();
    }
}

上述例子中有两个地方存在错误，你能看出来吗？

该例子中存在两个错误，首先，throw1()方法不想处理所导致的异常，因而它必须声明throws子句来列举可能引发的异常即IllegalAccessException；其次，main()方法必须定义try-catch语句来捕获该异常。

正确例子如下：

复制代码
class TestThrows{
    
    
    static void throw1() throws IllegalAccessException {
    
    
        System.out.println("Inside throw1 . ");
        throw new IllegalAccessException("demo");//人为抛出异常
    }
    public static void main(String[] args){
    
    
        try {
    
    
            throw1();
        }catch(IllegalAccessException e ){
    
    
            System.out.println("Caught " + e);
        }
    }
}

3.throws抛出异常的规则

• 如果是非受检查异常，即Error、RuntimeException或它们的子类 ，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。
• 必须声明方法可抛出的任何受检异常。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误
• 仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。
• 调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

4.什么时候用throws / try-catch

如果是因为传入的参数 导致异常的发生，则可以通过throws抛出异常。通常是谁调用谁处理；

如果是在此方法中调用时，可以使用try-catch处理异常，并使程序正常运行；

1，观察下面的函数，只有当传入的参数错误时，程序才会出错；

2，这时可以选择，谁调用谁处理的策略；

3，如何处理

throw

1.throw 概念

throw关键字表示在程序中人为的抛出一个异常，因为从异常处理机制来看，所有的异常一旦产生之后，实际上抛出的就是一个异常类的实例化对象，那么此对象也可以由throw直接抛出。（真正应用的时候，自己造异常还是比较麻烦的，之接加判断也可以出现相同效果。所以用的比较少）

2.实例

1，回顾以前编写的函数

2，所以在发生异常时，需要告诉调用函数，发生了什么问题，而不是自己默默处理

3，运行效果

（三）自定义异常（了解）

• 编写一个类， 继承Exception，并重写一参构造方法 即可完成自定义受检异常类型。
• 编写一个类， 继承RuntimeExcepion，并重写一参构造方法 即可完成自定义运行时异常类型（非受检异常类型）。

例如：

class MyException extends Exception{
    
     // 继承Exception，表示一个自定义异常类 
    public MyException(String msg){
    
     
        super(msg) ; // 调用Exception中有一个参数的构造 
    } 
}

自定义异常可以做很多事情， 例如：

class MyException extends Exception{
    
     
    public MyException(String msg){
    
     
        super(msg) ; //在这里给维护人员发短信或邮件， 告知程序出现了BUG。 
    } 
}

非受检异常（运行时异常）

1，设计自定义的运行时异常类

2，抛出自定义的异常

3，运行效果

受检异常

1，自定义受检异常

2，发现标红

3，抛出异常（受检查的异常必须明确抛出，运行时异常可以不抛出）

4，测试效果

5，解决方法

6，不解决，继续执行

RuntimeExcepion与Exception的区别

注意观察如下方法的源码：

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

此方法抛出了异常， 但是使用时却不需要进行try…catch捕获处理，

原因： 因为NumberFormatException并不是Exception的直接子类，而是RuntimeException的子类，只要是RuntimeException的子类，则表示程序在操作的时候可以不必使用try…catch进行处理，如果有异常发生，则由JVM进行处理。当然，也可以通过try…catch处理。

四、总结