Java 异常 之深究学习(敲详细)

一.异常

1.1异常概念

异常,就是不正常的意思。
异常:指的是程序在执行过程中,出现的非正常的情况,最终会导致JVM的非正常停止。
在Java等面向对象的编程语言中,异常本身是一个类 , 产生异常就是创建异常对象并抛出了-个异常对象。
			Java处理异常的方式是中断处理。
异常指的并不是语法错误语法错了 ,编译不通过，不会产生字节码文件,根本不能运行.

1.2异常体系

异常机制其实是帮助我们找到程序中的问题,异常的根类是java. lang. Throwable ,
其下有两个子类:
 java. lang. Error 与 java. lang . Exception
平常所说的异常指java. lang. Exception

Throwable体系:

●Error:严重错误Error ,无法通过处理的错误,只能事先避免,好比绝症。
●Exception:表示异常,异常产生后程序员可以通过代码的方式纠正,使程序继续运行,是必须要处理的。
好比感冒、阑尾炎。

1.3异常分类

我们平常说的异常就是指Exception ,因为这类异常一旦出现,我们就要对代码进行更正,修复程序。

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常?
●编译时期异常:checked异常。 在编译时期,就会检查，如果没有处理异常,则编译失败。(如日期格式化异常)
●运行时期异常:runtime异常。在运行时期,检查异常.在编译时期，运行异常不会编译器检测(不报错)。(如数学异
常)

编译期异常

解决方式1:

存在问题:

解决方式2:(使用 try…catch )

运行期异常: 即RuntimeException : ArrayIndexOutOfBoundsException

错误Error 示例:

OutOfMemoryError : Java heap space (内存溢出的错误,创建的数组太大了,超出了给JVM分配的内存)

1.4 异常的产生过程解析

1.4.1 写个异常程序如下:

ArrayIndexOutOfBoundsException(数组下标索引越界异常)

package com.dhl.beyond.expection;

public class Demo02Exception {
    public static void main(String[] args) {

        int[] arr = {1,2,3};

        System.out.println( getElement(arr,3));
    }

    /*
    定义一个方法,获取数组指定索引处的元素
    参数: int[] arr
          int index
     */
    public static int getElement(int[] arr, int index){
        int ele = arr[index];
        return  ele;
    }
}

1.4.2 详细分析异常产生过程

二.异常处理

Java异常处理的五个关键字: try. catch、 finally、 throw、 throws

异常集: Exception 的子类对象

2.1 throw 关键字

作用:

可以使用throw关键字在指定的方法中抛出指定的异常

使用格式:

throw new xxxException("异常产生的原因");

注意:

1. throw 关键字必须写在方法的内部
2. throw 关键字后边的 new 的对象必须是 Exception 或者 Exception的子类对象
3. throw 关键字抛出指定的异常对象,我们就必须处理这个 异常对象
          * throw 关键字后面创建的是 RuntimeException 或者是 RuntimeException 的子类对象,
  我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)
          * throw 关键字后面创建的是 编译异常时(写代码时候遇到的异常),
  我们就必须处理这个异常(要么throws, 要么 try...catch).

补充:(举例如下)

在工作中,我们首先必须对某个方法传递过来的参数进行合法性校验
    如果参数不合法,那么我们就必须使用抛出异常的方式,告知方法的调用者,传递的参数又问题

package com.dhl.beyond.expection;

public class Demo03Throw {
    /*
    定义一个方法,获取数组索引处指定的索引值:
    参数:
        int[] arr;
        int index;

    在工作中,我们首先必须对方法传递过来的参数进行合法性校验
    如果参数不合法,那么我们就必须使用抛出异常的方式,告知方法的调用者,传递的参数又问题

    注意:
        ArrayIndexOutOfBoundsException 是运行期异常,故我们不用处理
        NullPointerException 是运行期异常,故我们不用处理
     */

    public static void main(String[] args) {
        int[] arr = {1,2,3};
        System.out.println(getElement(arr,6));
    }


    public static int getElement(int[] arr , int index) {
        /*
        我们可以对传递过来的数组 进行合法性校验
        如果数组 arr 的值是 null
        那么 我们就抛出空指针异常,告知方法的调用者 值是 null

        如果 index 不在数组范围,
        那么我们就抛出 数组索引越界异常,告诉方法调用者 "传递的索引超出了数组的使用范围"
         */
        if(arr == null){
            throw new NullPointerException("传递的数组值是null");
        }
        if(index>arr.length-1 || index<0){
            throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
        }
        int ele =  arr[index];
        return ele;
    }
}

2.2 使用Objects非空判断

类0bjects,曾经提到过它由一些静态的实用方法组成,
这些方法是nullsave (空指针安全的)或null-tolerant (容忍空指针的),
那么在它的源码中 ,对 对象为null的值进行了抛出异常操作。

public static <T> T requireNonNull(T obj ) : 查看指定引用对象是不是null。

源码:

 public static <T> T requireNonNull(T obj) {
                if (obj == null)
                throw new NullPointerException( );
            return obj ;
       }

常用的两个 Objects 非空静态方法的使用:

Objects.requireNonNull(object);
Objects.requireNonNull(object,"传递的对象值是null");

实例

package com.dhl.beyond.expection;

import java.util.Objects;

public class Demo04Objects {
    public static void main(String[] args) {
        method(null);
    }

    public static void method(Object object){
        //对传递过来的参数进行合法性判断,判断是否为null
       /* if(object == null)
            throw new NullPointerException("传递的对象值是null"); */
      //  Objects.requireNonNull(object);
        Objects.requireNonNull(object,"传递的对象值是null");
    }
}

2.3 声明异常throws

throws关键字: 异常处理的第一种方式, 交给别人处理

作用:

    当方法内部抛出异常对象的时候,那么我们就必须处理这个异常对象
    可以使用 throws 关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理(自己不处理,让别人处理),
    																	最终交给JVM处理-->中断程序

使用格式: 在方法声明时候使用

   修饰符 返回值 类型 方法名(参数列表) throws AAAException,BBBException,....{
            throw new AAAException("产生原因");
            throw new BBBException("产生原因");
            ....
 }

注意:

1. throws 关键字 必须写在方法声明处
2. throws 关键字 后面声明的异常 必须是 Exception 或者 Exception的子类
3. 方法内部如果抛出了多个异常对象,那么 throws 后边必须也声明多个异常
        如果抛出的多个异常对象有子父类关系,那么 直接声明 父类异常 即可
4. 调用了一个声明抛出异常的方法, 我们就必须得处理声明的异常
        要么继续使用 throws 声明抛出, 交给方法的调用者处理, 最终交给JVM
        要么 try...catch 自己处理异常

示例如下:

package com.dhl.beyond.expection;

import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo05Throws {
    /*
    FileNotFoundException extend IOException, 所以可以自己声明 IOException 即可
     */

    public static void main(String[] args) throws FileNotFoundException,IOException {

        readFile("c:\\a.tx");
    }


    /*
    定义一个方法, 对传递的文件路径进行合法性判断
    如果路径不是" C:\\a.txt" ,那么我们就抛出 文件找不到异常,告知方法的调用者

    注意:
        FileNotFoundException 是编译异常,抛出了这个异常就必须进行处理
            可以使用 throws继续声明抛出FileNotFoundException这个异常对象,让方法调用者处理
     */

    public static void readFile(String fileName) throws FileNotFoundException,IOException {
        if(!fileName.equals("c:\\a.txt")){
            throw new FileNotFoundException("传递的文件路径不是 c:\\a.txt");
        }

        /*
        如果传递的路径,不是 .txt 结尾
        那么我们就抛出 IO 异常,告知方法的调用者,文件的后缀名不对
         */
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题,读取文件");
    }
}

2.4 捕获异常try…catch (第二种处理异常的方式)

(注: 针对于上一种方式, 其作用区别在于 抛出异常之后还可以继续执行后续代码(但是try发生异常的语句的后面的代码不会执行), 而第一种方式经过 JVM 处理异常会直接中断程序)

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

1.该方法不处理，而是声明抛出，由该方法的调用者来处理(throws)。
2.在方法中使用try-catch的语句块来处理异常。

try-catch的方式 就是捕获异常。

●捕获异常: Java中对异常有针对性的语句进行捕获,可以对出现的异常进行指定方式的处理。

捕获异常语法如下:

try{
	编写可能会出现异常的代码
}catch(异常类型e){
	处理异常的代码
	//记录日志/打印异常信息/继续抛出异常
}

2.5 如何获取异常信息:

Throwable类中定义了一些查看方法:

public String getMessage() :获取异常的简要的描述信息和原因(提示给用户的时候，就提示错误原因)。
public String toString() :获取详细的异常的类型和异常描述信息(一般不用),打印对象时默认调用此方法. 
public void printStackTrace():打印异常的跟踪栈信息并输出到控制台,
											JVM打印异常对象时,默认调用此方法,打印的异常信息最全面

注意: public void printStackTrace() 包含了异常的类型异常的原因和异常出现的位置,所以在开发和调试阶段都常常使用printStackTrace.

2.6 finally代码块

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

finally 一般用于 资源释放(资源回收), 无论程序是否出现异常,都会执行

什么时候的代码必须最终执行?
当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开
的资源。

finally的语法:

try..catch...finally:自身需要处理异常,最终还得关闭资源。
注意:finally不能单独使用。
比如在我们之后学习的I0流中,当打开了一个关联文件的资源,最后程序不管结果如何,都需要把这个资源关闭

finally代码参考如下:

注意:当只有在try或者catch中调用退出JVM的相关方法，此时finally才不会执行,否则finally永远会执行。

2.7 异常注意事项:

2.7.1 多异常捕获处理

多个异常使用捕获又该怎么处理呢?
        1.多个异常分别处理
        2.多个异常一次捕获,多次处理
        3.多个异常一次捕获,一次处理

* 多个异常分别处理

*多个异常一次捕获,多次处理

注意事项:

  catch 里边定义的异常对象,如果又继承关系,则子类必须写在上面,父类必须写在下面,否则就会报错
 		 如下面所示,  ArrayIndexOutOfBoundsException extend IndexOutOfBoundsException

报错原因进行分析如下

*多个异常一次捕获,一次处理

即捕获时直接写 Exception 这个超类对象进行捕获所有异常

注意:

●运行时异常被抛出可以不处理。
		即不捕获也不声明抛出,默认交给JVM处理让其中断程序,什么时候不抛出异常了再继续执行后续代码。
●如果finally有return语句 永远返回finally中的结果,避免该情况.
●如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异
常。
●父类方法没有抛出异常,子类重写父类该方法时也不可抛出异常。此时子类产生该异常,只能捕获处理,不
能声明抛出.

2.7.2 finally有 return 语句时的情况

如果finally 有return语句,永远返回 finally 中的结果, 避免发生该情况

代码举例

package com.dhl.beyond.expection;
/*
 如果finally 有return语句,永远返回 finally 中的结果, 避免发生该情况
 */
public class Demo07Exception {

    public static void main(String[] args) {
        System.out.println(getA());
    }

    /*
    定义一个方法
     */
    public static int getA(){
        int a = 10;
        try {
            return a;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            a= 100;
            return a;
        }
    }
}

2.7.3 子父类异常

●如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常.

●父类方法没有抛出异常,子类重写父类该方法时也不可抛出异常。此时子类产生该异常,只能捕获处理,不能声明抛出

注意:

父类异常是什么样,子类异常就是什么样
ClassCastException: 类型转化异常

代码示例分析:

package com.dhl.beyond.expection;
/*
子父类异常:
    ●如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常.
    ●父类方法没有抛出异常,子类重写父类该方法时也不可抛出异常。
    	此时子类产生该异常,只能捕获处理,不能声明抛出

注意:
    父类异常是什么样,子类异常就是什么样
    ClassCastException: 类型转化异常
 */
public class Demo08Fu {
    public void show1() throws NullPointerException,ClassCastException{ }
    public void show2() throws IndexOutOfBoundsException{ }
    public void show3() throws IndexOutOfBoundsException{ }
    public void show4(){ }
}

class  Zi extends Demo08Fu{
    //子类重写父类方法,抛出和父类相同的异常
    public void show1() throws NullPointerException,ClassCastException{ }

    //子类重写父类方法时,抛出父类异常的子类
    public void show2() throws ArrayIndexOutOfBoundsException{ }

    //子类重写父类方法时,不抛出异常
    public void show3(){ }

    //子类重写父类的无异常方法时,子类也不能抛出异常,内部的异常只能捕获处理,不能抛出(即使用 try...catch)
    public void show4(){ }
}

三.自定义异常

3.1概述

为什么需要自定义异常类:

我们说了Java中不同的异常类分别表示着某-种具体的异常情况，那么在开发中总 是有些异常情况是SUN没有定义
好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题，考试成绩负数问题等等。
在上述代码中,发现这些异常都是JDK内部定义好的,但是实际开发中也会出现很多异常,这些异常很可能在JDK中
没有定义过，例如年龄负数问题考试成绩负数问题.那么能不能自己定义异常呢?

什么是自定义异常类:

在开发中根据自己业务的异常情况来定义异常类.
自定义一个业务逻辑异常: RegisterException一个注册异常类。

异常类如何定义:(必须继续Exception 或者 RuntimeException)

1.自定义一个编译期异常:自定义类并继承于java.lang.Exception。 需要处理 throws 或者 try...catch
2.自定义一个运行时期的异常类:自定义类并继承于java.lang.RuntimeException。  无需处理,JVM会自动处理

3.2自定义异常的练习

要求:我们模拟注册操作,如果用户名已存在,则抛出异常并提示:亲,该用户名已经被注册。

首先定义一个登陆异常类RegisterException :

package com.dhl.beyond.expection;

public class RegisterException extends Exception {
    //添加一个无参的构造方法
    public RegisterException(){}

    //添加一个带异常信息的构造方法
    //(通过源码发现,所有的异常类都会有一个带异常信息的构造方法,
    // 方法内部会调用父类异常信息的构造方法,让父类来处理)
    public RegisterException(String message){
        super(message);
    }
}

测试类

public class Demo {
//模拟数据库中已存在账号
private static String[] names = {"d" , "h" , "l"};
	public static void main(String[] args) {
		//调用方法
		try{
		/可能出现异常的代码
		checkUsername("h");
		System. out. print1n( "注册成功" );//如果没有异常就是注册成功
		}catch(RegisterException e){
		//处理异常
		e. printStackTrace();
		}
	}
	//判断当前注册账号是否存在
	//因为是编译期异常,又想调用者去处理所以声明该异常
	public static boolean checkUsername(String uname) throws RegisterException {
		for (String name : names) {
		if(name . equals (uname)){//如果名字在这里面就抛出登陆异常
			throw new RegisterException( "亲" +name+"已经被注册了! ");
			}
		}
		return true;
	}
}