异常

作者: 上炼致知 | 来源:发表于2020-05-21 19:20 被阅读0次

异常和模块
python多线程
dart 异常
Java基础之异常
python核心编程-错误与异常
motan(RPC)系统梳理知识点
异常
从零构架个人博客网站(二)-全局异常处理
Node.js异常处理
python 异常

异常

异常概述

Java代码在运行时期发生的问题就是异常；

异常类：在Java中把异常信息封装成了一个类，当出现问题时，就会创建异常类对象，并抛出异常相关信息（如异常出现的位置、原因等）；

异常的继承体系

Throwable是所有错误与异常的超类（祖宗类）；

Exception类及其子类是Throwable的一种形式，它用来表示java程序中可能会产生的异常，并要求对产生的异常进行合理的异常处理；

在Exception类中有一个子类：RuntimeException子类，RuntimeException及它的子类只能在Java程序运行过程中出现；

Error类也是Throwable的子类，与Exception平级；表示java程序中可能会产生的严重错误，解决办法只有修改代码避免Error错误的产生；

Throwable:  所有错误与异常的超类（祖宗类）
        |- Error 错误
        |- Exception 异常
             |- RuntimeException 运行期异常

异常与错误的区别

异常：指程序在编译、运行期间发生了某种异常（XxxException），可以对异常进行具体的处理，若不处理异常，程序将会结束运行；

错误：指程序在运行期间发生了某种错误（XxxError），Error错误通常没有具体的处理方式，程序将会结束运行，Error错误的发生往往都是系统级别的问题，都是jvm所在系统发生的，并反馈给jvm的，我们无法针对处理，只能修正代码；

异常对象产生和处理过程

异常对象产生和处理过程的执行流程.JPG

public class ArrayTools {
    public static int getElement(int[] arr, int index) {
        int element = arr[index];
        return element;
    }
}
public class Test {
    public static void main(String[] args) {
        int arr[] = {11, 22, 33};
        int num = ArrayTools.getElement(arr, 4);

        System.out.println("num = " + num);
        System.out.println("over");
    }
}
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
    at main.api.ArrayTools.getElement(ArrayTools.java:5)
    at main.api.Test.main(Test.java:9)

上述代码异常产生原因：

由于没有找到4索引，导致运行时发生异常；这个异常jvm认识：ArrayIndexOutOfBoundsException；这个异常Java本身有描述：异常的名称、异常的内容，异常的产生位置；java将这些信息直接封装到异常对象中new ArrayIndexOutOfBoundsException(4)；
throw new ArrayIndexOutOfBoundsException(4)；产生异常对象；JVM将产生的异常抛给调用者main()方法；
main()方法接收到了数组索引越界异常对象；由于main()方法并没有进行处理异常，main()方法就会继续把异常抛给调用者java；当JVM收到异常后，将异常对象中的名称、异常内容、位置都显示在控制台上，同时让程序立刻停止；

异常的处理方式：

JVM的默认处理方式：把异常的名称、原因、位置等信息输出在控制台，同时结束程序；一旦有异常发生，其后面的代码不能继续执行；
解决程序中异常的手动方式：
- 编写处理代码 try...catch...finally
- 抛出throws

抛出异常 throw

在java中提供了一个关键字throw，她用来抛出一个指定的异常对象；

什么时候用throw关键字：当调用方法使用接收到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来，这时需要使用抛出异常的方式来告诉调用者；

使用throw关键字具体操作：

创建一个异常对象，封装一些提示信息（信息可以自己编写）；
通过关键字throw将这个异常对象告知调用者，throw 异常对象;

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行；

throw关键字使用格式：throw new 异常类名(参数)

方法声明异常 throws

声明：将问题标识出来，报告给调用者；如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理；

声明异常格式：修饰符返回值类型方法名(参数) throws 异常类名1，异常类名2...{} throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开；

捕获异常 try...catch...finally

捕获：java对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理；

捕获异常格式：

try {
        //需要被检测的语句
} catch(异常类 变量) {
    //异常的处理语句
} finally {
    //一定会被执行的语句
}

try：该代码块中编写可能会产生异常的代码；

catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理；

finally：有一些特定的代码无论对异常是否发生，都需要执行；另外，因为异常会引发程序跳转，导致有一些语句执行不到，而finally就是解决这个问题的，在finally代码块中存放的代码都已定会被执行到；

try...catch...finally异常处理的组合方式

try catch finally组合：检测异常，并传递给catch处理，并在finally中进行资源释放；
try catch组合：对代码进行异常检测，并对检测的异常传递给catch处理，对异常进行捕获处理
一个try多个catch组合：对代码进行异常检测，并对检测的异常传递给catch处理，对每种异常信息进行不同的捕获处理；
```
try {
      throw new Exception()//产生异常，直接捕获处理
} catch(XxxException e) {
      //处理方式
} catch(YyyException e) {
      //处理方式
} catch(ZzzException e) {
      //处理方式
}
```
注意：这种异常处理方式，要求多个catch中的异常不能相同，且若catch中的异常之间父子类的继承关系，那么子类异常要求在上面的catch处理，越高级的父类异常在越下面的catch处理；
try finally组合：对代码进行异常检测，检测到异常后因为没有catch，所以一样会被默认jvm抛出，一场是没有捕获处理的，但是功能所开启资源需要进行关闭，所以finally只为关闭资源；

在实际开发中，使用try还是throws处理方式？：能处理的尽量自己处理，建议用try...catch；

运行时期异常

RuntimeException和它的所有子类异常，都属于运行时期异常，NullPointerException、ArrayIndexOutOfBoundsException等都属于运行时异常；
运行时异常特点：
- 方法中抛出运行时异常，方法定义中无需throws声明，也无需处理此异常；
- 运行时期异常一旦发生，需要程序人员修改源代码；
```
public class Test {
    public static void main(String[] args) {
        method();
    }
    public static void method() {
        throw new RuntimeException();
    }
}
```

方法重写时候异常的处理

子类覆盖父类方法时，如果父类的方法声明异常，子类只能声明父类异常，或者该异常的子类，或者不声明；
当父类方法声明多个异常时，子类覆盖时只能声明多个异常的子集；
当被覆盖的方法没有异常声明时，子类覆盖时无法声明异常；

问题：父类或者接口中没有声明异常，而实现的子类覆盖方法时发生了异常，怎么办？

答：无法进行throws声明，只能catch的捕获；万一问题处理不了，catch中继续throw抛出，但是只能将异常转换成RuntimeException子类抛出；

interface Inter {
        public abstract void method();
}
class Zi implements Inter {
        public void method(){ //无法声明 throws Exception
                int[] arr = null;
                if (arr == null) {
                        //只能捕获处理
                        try{
                                throw new Exception(“哥们，你定义的数组arr是空的!”);
                        } catch(Exception e){
                            System.out.println(“父方法中没有异常抛出，子类中不能抛出Exception异常”);
                            //我们把异常对象e，采用RuntimeException异常方式抛出
                                throw new RuntimeException(e);
                        }
                }
        }
}

Throwable类方法

String getMessage() 返回该异常的详细信息字符串，即异常提示信息；
String toString() 返回该异常的名称与详细信息字符串；
void printStackTrace() 在控制台输出该异常的名称与详细信息字符串，异常出现的代码位置；

自定义异常

java中所有的异常类都是继承Throwable，或者继承Throwable的子类，这样该异常才可以被throw抛出；

并且每个异常中都调用了父类的构造方法，把异常信息传递给了父类，让父类进行异常信息的封装；

class NullPointerException extends RuntimeException {
    public NullPointerException() {
        super();
    }
    public NullPointerException(String s) {
        super(s);
    }
}

定义格式：

Class 异常名 extends Exception {
    public 异常名() {}
    public 异常名(String s) {
        super(s);
    }
}

为什么要定义构造函数，因为看到java中的异常描述类中有提供对异常对象的初始化方法；

自定义异常继承Exception必须要throws声明，一声明就告知调用者进行捕获，一旦问题处理了调用者的程序会继续执行；
自定义异常继承继承RuntimeException不需要throws声明的，这时调用不需要编写捕获代码的，因为调用根本就不知道有问题，一旦发生异常，调用者程序停掉，并有jvm将信息显示到屏幕，让调用者看到问题，修正代码；