java异常

异常概念

异常，就是不正常的意思
指的是程序在执行的过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

异常体系

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

Throwable体系：

· Error：严重错误Error无法通过处理的错误，只能事先避免。
· Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。

Throwable常用方法：

异常产生过程

异常的处理

throw关键字

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

使用格式：
throw new xxxException (“异常产生的原因”)；

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

在指定的方法中抛出指定的方法异常

 private static int  show05(int[] n,int index){
        //NullPointerException是一个运行期异常，我们不用处理，默认交给JVM处理
        //ArrayIndexOutOfBoundsException是一个运行期异常，我们不用处理，默认交给JVM处理
        if(n==null){
            throw new NullPointerException("数值不能为空");
        }
        if(index<0&&index>n.length-1){
            throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的范围")
        }
        return 0;
    }

Object 非空判断_requireNonNull

private static void show06(Object obj){
        //判断是非为空的异常
      //  Objects.requireNonNull(obj);
        //requireNonNull重载函数
        Objects.requireNonNull(obj,"为空");
    }

Exception in thread "main" java.lang.NullPointerException: 为空

处理异常

throws关键字：

声明异常：异常处理的第一种方式，交给别人处理，
作用：
当前方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象，可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理（自己不处理交给别人处理），最终交给JVM处理—>中断处理

使用格式
修饰符 返回值类型 方法名（参数列表 ）throw AAAException,BBBException…{
throw new AAAException(“产生原因”)；
throw new BBBException(“产生原因”)；
、、、
}
注意：
1.throw关键字必须写在方法声明处
2.throw关键字后边声明的异常对象必须是Exception或Exception的子类
3.方法内部如果抛出了多个异常对象，那么throws 后边必须也声明多个异常。如果抛出的异常有字符类关系，那么直接声明父类异常即可
4.调用了一个声明抛出异常的方法，我们就必须的处理声明的异常，
要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM
要么try…catch自己处理异常

 //但FileNotFoundException和IOException是继承关系，直接声明父类异常即可
    private static void show07(String fileName) throws FileNotFoundException,IOException {
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的方式错误");
        }
        if(!fileName.equals("c:\\a.txt")){
           throw new FileNotFoundException("传递的文件途径不对");
       }
    }

Exception in thread "main" java.io.IOException: 文件的方式错误

try…catch

异常处理的第二种方式，自己处理异常
格式：
try{
可能产生异常的代码
}catch(){
异常的处理逻辑，异常异常对象之后，怎么处理异常对象
一般在工作中，会把异常的信息记录单到一个日志中
}
…
catch(异常类名 变量名){

}

注意：
1.try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
2.如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try…catch之后的代码
如果么有产生异常，就不会执行catch中的异常处理逻辑，执行完try代码，继续执行try…catch之后的代码

public static void main(String[] args)  {
        try {
            show08("dwaw.tx");
        }catch (IOException e){
            System.out.println("文件地址错误");
        }
        System.out.println("后续代码");

    }

private static void show08(String fileName) throws IOException {

        if(!fileName.equals("c:\\a.txt")){
            throw new FileNotFoundException("传递的文件途径不对");
        }


    }

文件地址错误
后续代码

Throwab类中3个处理异常的方法

 public static void main(String[] args)  {
        try {
            show08("dwaw.tx");
        }catch (IOException e){
            System.out.println("文件地址错误");
            /*Throwable类中3个处理异常的方法
            string getMessage()返回此throwable的简短描述
            String toString()返回此throwable的详细消息字符串
            void prinStackTrace()JVM打印异常对象，默认方法，打印异常信息是最全面的


        */
            System.out.println(e.getMessage());
            System.out.println(e.toString());
            e.printStackTrace();
        }
        System.out.println("后续代码");

    }

文件地址错误
传递的文件途径不对
java.io.FileNotFoundException: 传递的文件途径不对
后续代码
java.io.FileNotFoundException: 传递的文件途径不对
	at cn.day05.code.show08(code.java:157)
	at cn.day05.code.main(code.java:17)

finally代码块

finally代码块
格式：
try{
可能产生异常的代码
}catch(){
异常的处理逻辑，异常异常对象之后，怎么处理异常对象
一般在工作中，会把异常的信息记录单到一个日志中
}
…
catch(异常类名 变量名){
}finally{
无论是否出现异常都会执行
}

注意：
1.finally不能单独使用，必须和try一起使用
2.finally一般用于资源释放（资源回收），无论程序是否出现异常，最后都要资源释放（IO）
3.若果finally中有return语句，永远返回finally中的结果，避免该情况

异常注意事项

多个异常使用捕获又该如何处理
1.多个异常分别处理
2.多个异常一次捕获多次处理（一个tyr可以对应多个catch）
注意： catch中定义的变量，如果有子父类关系，那么子类必的异常变量必须写在父类的上边，否则就会报错。
3.多个异常一次捕获一次处理（所有异常有相同父类或有继承关系，创建父类异常）

运行时异常被抛出可以不处理，即不抛出也不捕获，默认给虚拟机处理。

子父类异常
1.如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常
2.父类方法没有抛出异常，子类重写父类方法时也不可以抛出异常。此时此时子类产生该异常，只能捕获处理，不能声明抛出

public class dome {
    public void show01()throws NullPointerException,ClassCastException{}
    public void show02()throws IndexOutOfBoundsException{}
    public void show03()throws IndexOutOfBoundsException{}
}
	public void show04(){}

class zi extends dome{
    //抛出和父类相同的异常
    @Override
    public void show01() throws NullPointerException, ClassCastException {
        super.show01();
    }
    //抛出父类异常的子类

    @Override
    public void show02() throws ArrayIndexOutOfBoundsException {
        super.show02();
    }
    //不抛出异常

    @Override
    public void show03()  {
        super.show03();
    }
     //父类不抛出，子类也不能抛出
     public void show04(){}
}

自定义异常

自定义异常类:
java提供的异常类，不够我们使用，需要自己定义一些异常类

格式：
public class XXXexception extend Exception /RuntimeException{
    添加一个空参数的构造方法
    添加一个带异常信息的构造方法
}

public class RegisterException extends Exception {
    //添加一个空构造方法
    public RegisterException(){

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