关于Java异常的学习

异常

简介

java.lang.Throwable类是java语言中所有错误或异常的超类
Exception：编译期异常，出现编译器异常，必须处理要么throws要么try … catch

RuntimeException:运行期异常，无需出理，交给虚拟机处理（中断处理）

Error：错误 运行期错误（相当于癌症，必须修改源码）

异常分类

这张图记住了，可以直接看到很多异常

//Throwable类中定义了三个异常处理的方法
String getMessage()     //返回此throwable的简短描述
toString()              //返回throwable的详细消息字符串
printStackTrace()      // Jvm打印异常对象，默认次方法,打印异常信息最全

java异常处理的五个关键字

try

捕获异常

try catch格式：

​ try{

​ 可能产生异常的代码

​ }catch(定义一个异常变量，用来接收try中抛出的对象) {

​ 异常的处理逻辑，怎么处理异常对象一般工作中，会把异常的信息记录到一个日志中

​ }

​ }catch可以有多个

注意事项：

1.try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象

2.如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try catch之后的代码如果try中没有产生异常，那么就不会执行catch中的异常处理逻辑，执行完try的代码，继续执行catch之后的代码后边有代码会继续执行

catch

finally

Finally代码块，适合try代码块一起使用
格式：
try{
可能产生异常的代码
}catch(定义一个异常变量，用来接收try中抛出的对象) {
异常的处理逻辑，怎么处理异常对象
一般工作中，会把异常的信息记录到一个日志中
}finally{
无论是否出现异常都会执行
}
catch可以有多个
注意：
1.Finally不能单独使用
2.Finally一般用于资源回收，无论程序是否出现异常，我们最后都会资源释放（IO）

throw

throw :使用格式
throw new xxxException(“异常产生的原因”)
注意：
1.throw关键字必须写在方法的内部
2.throw关键字后边new的对象必须是Exception或者其子类
3.throw关键字抛出异常对象我们就必须处理异常
throw关键字后边抛出的是RuntimeException或者是其子类对象，我们可以不处理，默认交给JVM处理（打印异常对象，中断指令）
throw关键字创建的是编译异常，我们必须处理这个异常，要么throw要么try catch

public static int getElement(int[] arr, int index) {
        //我们可以对传递过来的阐述进行合法性校验，如果arr的值为空，空指针异常
if (arr == null) {    
   throw new NullPointerException("传递的数组的值为null");//这个是运行期异常RuntimeException异常
}

注：运行时异常我们可以不处理，交给jvm

throws

throws关键字，异常处理的第一种方式，交给别人处理作用：

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

中断处理使用格式：在方法声明时使用修饰符 返回值类型 方法名（参数列表） throwsthrow new xxxException(“产生原因”)throw new xxxException(“产生原因”)

注意：

1.throws关键字必须写在方发声明处

2.throws关键字后边声明的异常必须是Exception或者其子类

3.方法内部如果抛出了多个异常，那么throws后边也声明多个异常如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可

4.调用了一个声明抛出异常的方法就必须处理声明的异常，要么继续使用throws声明抛出，交给方法的调用者，最终交给JVM处理，中断处理要么try catch自己处理异常

多个异常处理方式

1.多个异常分别处理

        try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]);
        }catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e);
        }
        try{
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));
        }catch (IndexOutOfBoundsException e){
            System.out.println(e);
        }

2.多个异常一次捕获

多次处理注意事项：catch里边定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上边，否则会报错

        try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]);
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));
        }catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e);
        }
        catch (IndexOutOfBoundsException e) {
            System.out.println(e);
        }
        catch (IndexOutOfBoundsException e) {
            System.out.println(e);
        }
        catch (ArrayIndexOutOfBoundsException e) {有子父类关系
            System.out.println(e);
        }
        catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e);
        }

3.多个异常一次捕获一次处理

try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]);
        }
        catch (IndexOutOfBoundsException e) {
           //数组集合产生的异常都能处理，最好写     Exception
            System.out.println(e);
        }

自定义异常

1.示例

/*
自定义异常类：
java提供给我们使用的异常类不够我们使用，要自己定义些异常类
格式：
public class xxxException extends Exception/RuntimeException
添加一个空参数构造方法
添加一个带异常信息的构造方法
注意事项：
1.自定义异常类一般都是Exception结尾，说明该类是异常类
2.自定义异常类，必须继承Exception或者RuntimeException类
继承Exception：那么自定义异常类就是一个编译期异常，如果方法内部抛出了编译期异常，就必须处理这个异常，
要么throw要么try  catch
继承RuntimeException：那么自定义的异常类就是一个运行期异常，我们无法处理，必须交给虚拟机处理（中断处理）

 */

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

2.使用自己定义的异常

public class Demo02RegisterException extends Exception{
    //使用数组保存已经注册过的用户名
    static String[] userNames = {"java","python","go","php"};
    //空参数的构造函数
    public Demo02RegisterException() {
        super();
    }
    //带异常信息的构造函数
    public Demo02RegisterException(String s) {
        super(s);
    }

    public static void main(String[] args) /*throws Demo02RegisterException*/ {
        //ArrayList<String> str1 = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入注册的用户名：");
        String s = sc.next();
        //str1.add(s);
        checkUsername(s);

    }
    public static void checkUsername(String s) /*throws Demo02RegisterException*/{
        for (String name:userNames
             ) {
            if(name.equals(s)){
                try {
                    throw new Demo02RegisterException("亲，该用户名已被注册");
                } catch (Demo02RegisterException e) {
                    e.printStackTrace();
                    return;//结束方法
                }
            }
        }
        System.out.println("恭喜您，注册成功！");
    }
}

);
} catch (Demo02RegisterException e) {
e.printStackTrace();
return;//结束方法
}
}
}
System.out.println(“恭喜您，注册成功！”);
}
}