Java 异常

1、异常的定义
异常:就是不正常,是指程序在运行时出现的不正常情况。其实就是程序中出现的问题。 这个问题按照面向对象思想进行 述,并封装成了对象。因为问题的产生有产生的原因、有问题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这些信息进行封装。异常就是 java 按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。

异常的体系 Throwable
Error
通常指 JVM 出现重大问题如:运行的类不存在或者内存溢出等。
不需要编写针对代码对其处理,程序无法处理。
Exception
在运行时运行出现的一些情况,可以通过 try,catch,finally 处理

异常处理两种方式:
1、捕获异常:try catch 直接处理可能出现的异常!
2、声明异常:throws 声明告诉调用者可能的异常,暴露问题,调用者自己处理!

我的总结：
1.Exception和Error的字类名大都是以父类名作为后缀
2.Java异常其实是对不正常情况的一种描述，并将其封装成对象
3.Java在设计异常体系时，将容易出现的异常情况都封装成了对象

2、异常处理格式
异常处理的 5 个关键字 try ,catch, finally。throw, throws

try{    //可能出现异常的代码}catch(Exception e){//e用于接收try检测到的异常对象。    //处理该异常类型的语句    System.out.println("message:"+e.getMessage());//获取的是异常的信息。     System.out.println("toString:"+e.toString());//获取的是异常的名字+异常的信息。     e.printStackTrace();//打印异常在堆栈中信息；异常名称+异常信息+异常的位置。}finally {    //一定会执行的代码}

备注:当 try 语句块出现异常,程序会自动跳到 catch 语句块去找匹配的异常类型,并执行异常处理语句,finally 语句块是异常的统一出口。

我的总结：
1.捕获异常：先捕获小异常再捕获大异常
2.异常处理后，程序不会因为出现异常而退出

3、多异常处理
1.声明异常时尽可能声明具体异常类型,方便更好的处理;

2.方法声明几个异常就对应有几个 catch 块;

3.若多个 catch 块中的异常出现继承关系,父类异常 catch 块放在最后;

4.在 catch 语句块使用 Exception 类作为异常类型时: 所有子类实例都可以使用父类接收(向上转型),即所有的异常对象都可以使用 Exception 接收;


注意：在java处理多异常时，捕获小范围的异常必须放在大范围异常之前。

4、异常的分类
1：编译时被检查的异常，只要是Exception及其子类都是编译时被检测的异常。在程序中必须使用 try…catch 处理;
2：运行时异常，其中Exception有一个特殊的子类RuntimeException，以及RuntimeException的子类是运行异常，也就说这个异常是编译时不被检查的异常。Runtime 异常
可以不使用 try…catch 处理,但一旦出现异常就将由 JVM 处理。

异常的分类之 Runtime 异常
RuntimeException(运行时异常)是指因设计或实现方式不当而导致的问题. 说白了,就是程序员造成的,程序员小心谨慎是完全可以避免的异常.比如,事先判断对象是否 为 null 就可以避免 NullPointerException 异常,事先检查除数不为 0 就可以避免 ArithmeticException 异常;
特点:
这种异常 Java 编译器不会检查它,也就说程序中出现这类异常的时候,即使不处理也没有问题,但是一旦出现异常,程序将异常终止,若采用异常处理,则会被相应的程序执行处理.

异常的分类之 Checked 异常
除了 RuntimeException 以及子类,其他的 Exception 及其子类都是受检查异常,我们也可 以称为非 RuntimeException 异常.
特点:
Java 编译器会检查它,也就说程序中一旦出现这类异常,要么是没有 try-catch 语句捕获, 或 throws 语句没有声明抛出它,编译就不会通过,也就说这种异常,程序要求必须处理.

5、声明异常(throws)
1.在可能出现异常的方法上声明抛出可能出现异常的类型: 声明的时候尽可能声明具体的异常,方便更好的处理. 当前方法不知道如何处理这种异常,可将该异常交给上一级调用者来处理(非 RuntimeException 类型的异常)。

2.方法一旦使用 throws 声明抛出方法内可能出现的异常类型, 该方法就可以不再过问该异常了;

3.一个方法调用另一个使用 throws 声明抛出的方法,自己要么 try…catch , 要么也 throws;
格式:
public 返回值类型 方法名(参数列表…) throws 异常类 A,异常类 B… {
}
这样标示后，调用者，在使用该功能时，就必须要处理，否则编译失败。

6、throw
自行抛出一个异常对象,抛出异常类的对象;
若 throw 抛出的是 Runtime 异常:
程序可以显示使用 try…catch 来捕获并处理,也可以不管,直接交给方法调用者处理;
若 throw 抛出 Checked 异常:
要么放在 try 里自己处理,要么放在一个 throws 声明的方法里面,交给调用者处理。

throws & throw
throws 用于在方法上声明该方法不需要处理的异常类型。
throw 用于抛出具体异常类的对象。
throws 与 throw 的区别:
thorws 用在方法上,后面跟异常类名,可以是多个异常类。 throw 用在方法内,后面跟异常对象,只能是一个。

7、finally
1.异常的统一出口:
不管 try 块程序是否异常,也不管哪个 catch 执行,finally 块总会执行。
2.try 语句块或会执行的 catch 语句块使用了 JVM 系统退出语句例外;//System.exit(1);
3.try 块必须和 catch 块或和 finally 同在,不能单独存在,二者必须出现一个。
4.不要在 finally 中使用 return 或 throw 语句,否则将会导致 try、catch中的return 或 throw 失效。

我的总结:finally 代码块只在一种情况下不执行:System.exit(0);

8、throw 和 catch 同时使用
当异常出现在当前方法中,程序只对异常进行部分处理,还有一些处理需要在方法的调用者中才能处理完成,此时还应该再次抛出异常,这样就可以让方法的调用者也能捕获到异常;

Eg:
public static void buy(String price) throws Exception {
try {
 if(price != null)
Double.parseDouble(price);
} catch (Exception e) {
e.printStackTrace();
throw new Exception(“价格不能只能是数字组成”);
}
}
public static void main(String[] args) {
try {
buy(null);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}

定义异常处理时，什么时候定义try，什么时候定义throws呢？
功能内部如果出现异常，如果内部可以处理，就用try；
如果功能内部处理不了，就必须声明出来，让调用者处理。

自定义异常：当开发时，项目中出现了java中没有定义过的问题时，这时就需要我们按照java异常建立思想，将项目的中的特有问题也进行对象的封装。这个异常，称为自定义异常。

自定义异常的步骤：
1：定义一个子类继承Exception或RuntimeException，让该类具备可抛性。
2：通过throw 或者throws进行操作。

当异常出现后，在子父类进行覆盖时，有了一些新的特点：
1：当子类覆盖父类的方法时，如果父类的方法抛出了异常，那么子类的方法要么不抛出异常要么抛出父类异常或者该异常的子类，不能抛出其他异常。
2：如果父类抛出了多个异常，那么子类在覆盖时只能抛出父类的异常的子集。

注意：
如果父类或者接口中的方法没有抛出过异常，那么子类是不可以抛出异常的，如果子类的覆盖的方法中出现了异常，只能try不能throws。
如果这个异常子类无法处理，已经影响了子类方法的具体运算，这时可以在子类方法中，通过throw抛出RuntimeException异常或者其子类，这样，子类的方法上是不需要throws声明的。

常见异常：
1、脚标越界异常（IndexOutOfBoundsException）包括数组、字符串；
空指针异常（NullPointerException）
2、类型转换异常：ClassCastException
3、没有这个元素异常：NullPointerException
4、不支持操作异常；