Java学习笔记之异常（一）

Throwable

直接已知子类：Error，Exception

Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。

Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。

异常和错误的区别：

Throwable:类是Java语言中所有错误或异常的超类。
Exception:编译期异常,进行编译(写代码)javo程序出现的问题
RuntimeException:运行期异常, java程序运行过程中出现的问题

异常就相当于程序得了一个小毛病(感冒，发烧)。把异常处理掉，程序可以继续执行(吃点药，继续革命工作)

Error:错误
错误就相当于程序得了一个无法治愈的毛病(非典，艾滋).必须修改源代码,程序才能继续执行

异常

在程序执行过程中，出现的非正常情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。异常指的并不是语法错误， 语法错了，编译不通过，不会产生字节码文件,根本不能运行

public class DemoException {
    public static void main(String[] args)throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd");
        Date date = null;
        //编译异常
        System.out.println(sdf.parse("202008-09"));
        /*try {
            System.out.println(sdf.parse("202008-09"));
        } catch (ParseException e) {
            e.printStackTrace();
        }*/
        System.out.println("Continue");
        //运行异常
        int []a = {1,2,3};
        try {
            //可能要出现异常的代码
            System.out.println(a[3]);
        }catch (Exception e)
        {
            //异常的处理逻辑
            System.out.println(e);
        }
         /*java.lang.OutOfMemoryError: Java heap space
        必须通过修改代码才能解决*/
        int b [] = new int [1024*1024*1024];//错误
    }
}

程序出现异常时通过throws ParseExpection会中断程序。利用try-catch不会中断程序，程序继续执行。

异常产生过程解析

throw关键字

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

使用方式：throw new xxxException(异常产生的原因)

注意事项：

1.throw关键字必须写在方法内部。

2.throw关键字new的对象必须是Exception或者Exception的子类对象

3.throw关键字抛指定的异常对象，我们就必须处理这个异常对象(指定的方法里，抛出指定异常)

throw关键字后边创建的是RuntimeException或者是Runt imeExcept ton的子类对象，我们可以不处理，默认交给JVM处理(打印异常对象，中断程序)throw关键字后边创建的是编译异常(写代码的时候报错)，我们就必须处理这个异常，要么throws,要么try...catch

public class DemoOne {
    public static void main(String[] args) {
        int arr[] = {1,2,3};
        int e = method(arr,3);//越界异常
        //int d= method(null,3);//Exception in thread "main" java.lang.NullPointerException: 空指针异常
        System.out.println(e);
    }
    public static int method(int arr[],int index){
        if(arr == null){
            throw new NullPointerException("空指针异常");
        }
        if(index<0||index>arr.length-1)
        {
            throw new IndexOutOfBoundsException("越界异常");
        }
        return arr[index];
    }
}

Exception in thread "main" java.lang.IndexOutOfBoundsException: 越界异常
	at com.lg.demo06.DemoOne.method(DemoOne.java:16)
	at com.lg.demo06.DemoOne.main(DemoOne.java:6)

Exception in thread "main" java.lang.NullPointerException: 空指针异常
	at com.lg.demo06.DemoOne.method(DemoOne.java:12)
	at com.lg.demo06.DemoOne.main(DemoOne.java:7)

Objects非空判断

public class DemoTwo {
    public static void main(String[] args) {
        method(null,1);
    }
    public static void method(int arr[],int index){
        /*一号*/
        /*if(arr == null){
            throw new NullPointerException("空指针异常！");
        }*/
        /*二号*/
        /*Objects.requireNonNull(arr);*/
        /*三号*/
        Objects.requireNonNull(arr,"空指针异常");

    }
}

三种结果：：

Exception in thread "main" java.lang.NullPointerException: 空指针异常！
	at com.lg.demo06.DemoTwo.method(DemoTwo.java:11)
	at com.lg.demo06.DemoTwo.main(DemoTwo.java:7)

Exception in thread "main" java.lang.NullPointerException
	at java.base/java.util.Objects.requireNonNull(Objects.java:221)
	at com.lg.demo06.DemoTwo.method(DemoTwo.java:13)
	at com.lg.demo06.DemoTwo.main(DemoTwo.java:7)

Exception in thread "main" java.lang.NullPointerException: 空指针异常
	at java.base/java.util.Objects.requireNonNull(Objects.java:246)
	at com.lg.demo06.DemoTwo.method(DemoTwo.java:14)
	at com.lg.demo06.DemoTwo.main(DemoTwo.java:7)

throws关键字:

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

使用格式:在方法声明时使用
修饰符返回值类型方法名(参数列表) throus AAAExcepiton, BBExcepiton...
throw new AAAExcepiton("产生原因");
throw new BBBExcepiton("产生原因");
注意:
1. throws关键字必须写在方法声明处
2. throws关键字后边声明的异常必须是Exception或者是Exception的子类

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

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

以下代码将异常交给JVM：

public class DemoThree {
    /**
     *JVM检测到异常，并创建异常对象，如果方法中没有异常处理逻辑那么将异常对象抛给该方法的调用者
     * 依次是：methodThree-->methodTwo-->methodOne-->main-->JVM
     * JVM终止当前程序的执行-->中断处理
     * */
    public static void main(String[] args) throws Exception {
        methodOne();
    }
    public static void methodOne() throws Exception {
        methodTwo();
    }
    public static void methodTwo() throws Exception {
        methodThree();
    }
    public static void methodThree() throws Exception{
        int arr[] = {1,2,3};
        System.out.println(arr[3]);
    }
}

以下代码通过try-catch将异常处理掉

public class DemoFour {
    /**
     *JVM检测到异常，并创建异常对象，如果方法中没有异常处理逻辑那么将异常对象抛给该方法的调用者
     * methodThree-->methodTwo-->methodOne(在此方法中通过try-catch将异常处理掉了)
     * */
    public static void main(String[] args){
        methodOne();
    }
    public static void methodOne(){
        //处理异常
        try{
            methodTwo();
        }catch (Exception e)
        {
            System.out.println(e);
        }
       
    }
    public static void methodTwo() throws Exception {
        methodThree();
    }
    public static void methodThree() throws Exception{
        int arr[] = {1,2,3};
        System.out.println(arr[3]);
    }
}