throw异常

1、of方法（jdk9对集合添加元素的优化，可以一次性添加多个元素）
// List、Set、Map接口的静态方法 static List of (E… elments)
使用前提：当集合中存储的元素个数已经确定了，不再改变时使用
注意：
of方法只适应于List、Set、Map接口，不适用于接口的实现类
of方法的返回值是一个不能改变的集合，集合不能再使用add、put方法添加元素，会抛异常
Set接口和Map接口调用of方法的时候，不能有重复的元素，否则会抛出异常

2、异常
java.lang.Throwable类是异常的超类，子类有Error和Exception
Exception：编译期异常
Error：错误（如：内存溢出），必须修改源代码
RuntimeException extends Exception：运行期异常
2.1 Exception
// 编译期异常
处理异常方式：
2.1.1 throw关键字
// 可以使用throw关键字在指定的方法中抛出指定的异常
使用格式：
throw new xxxException(“异常产生的原因”);
注意：

1. throw关键字必须写在方法的内部
   2.throw关键字后边new的对象必须是Exception或者Exception的子类对象
   3.throw关键字抛出指定的异常对象，就必须处理这个异常对象
   throw关键字后边创建的是RuntimeException或者是RuntimeException的 子类对象，可以不处理，默认交给JVm处理
   throw关键字后边创建的是编译异常，必须处理异常，要么throws，要么
   try…catch
   代码示例：

    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4};
        int index = 5;
        method(arr, 5);
    }
    public static int method(int[] arr,int index) {
        if (arr == null) {
            throw new NullPointerException("空指针异常");
        }
        if (index >= arr.length) {
            throw new ArrayIndexOutOfBoundsException("数组索引越界异常");
        }
        return arr[index];
    }

2.1.2 throws关键字
throws关键字:交给别人处理
作用：
当方法内部抛出异常对象的时候，必须处理异常，可以使用throws关键字处理异常，会把异常对象声明抛出给方法的调用者处理
使用格式：在方法声明时使用
修饰符 返回值类型 方法名(参数列表) throws AAAException, BBBException…{
throw new xxxException(“异常产生的原因”);
throw new xxxException(“异常产生的原因”);
}
注：

1. throws关键字必须写在方法声明处
2. throws关键字后边声明的异常必须是Exception或者Exception的子类
3. 方法内部如果抛出了多个异常对象，那么throws后边必须也声明多个异常（如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可）
4. 调用一个声明抛出异常的方法，就必须处理声明的异常，要么继续使用throws声明抛出，交给方法的调用者处理，要么try…catch自己处理异常
   代码示例：

    public static void main(String[] args) throws FileAlreadyExistsException {
        method("a.txt");
    }
    public static void method(String path) throws FileAlreadyExistsException{
        if (path != "a.txt") {
            throw new FileAlreadyExistsException("路径不存在");
        }
        System.out.println("打开文件");
    }

2.1.3 try…catch处理异常
// 自己处理异常
格式：
try{
可能产生异常的代码
}catch(定义一个异常的变量，用来接受try中抛出的异常对象) {
异常的处理逻辑
}catch(定义一个异常的变量，用来接受try中抛出的异常对象) {
异常的处理逻辑
}
…
catch(定义一个异常的变量，用来接受try中抛出的异常对象)
注意：

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

    public static void main(String[] args) {
        try{
            method("a.txt1");
        }catch (FileAlreadyExistsException e) {
            System.out.println("错误信息：" + e);
        }
    }
    public static void method(String path) throws FileAlreadyExistsException{
        if (path != "a.txt") {
            throw new FileAlreadyExistsException("路径不存在");
        }
        System.out.println("打开文件");
    }

3、 Throwable类中异常处理的3个方法
String getMessage() 返回此throwable的简短描述
String toString() 返回此throwable的详细消息字符串
void printStackTrace() jvm打印异常对象，默认此方法，打印的异常信息是最全面的
代码示例：

    public static void main(String[] args) {
        try{
            method("a.txt1");
        }catch (FileAlreadyExistsException e) {
            System.out.println(e); // 默认调用的toString方法 java.nio.file.FileAlreadyExistsException: 路径不存在
            System.out.println(e.getMessage()); // 路径不存在
            System.out.println(e.toString()); // java.nio.file.FileAlreadyExistsException: 路径不存在
            e.printStackTrace();
        }
    }
    public static void method(String path) throws FileAlreadyExistsException{
        if (path != "a.txt") {
            throw new FileAlreadyExistsException("路径不存在");
        }
        System.out.println("打开文件");
    }

4、finally代码块
格式：
try{
可能产生异常的代码
}catch(定义一个异常的变量，用来接受try中抛出的异常对象) {
异常的处理逻辑
}finally {
无论是否出现异常都会执行
}
注意：

1. finally不能单独使用，必须和try一起使用
2. finally一般用于资源释放，无论程序是否出现异常，最后都要资源释放
3. 尽量不要在finally中写return，不然一直返回的都是finally的return值
   代码示例：

    public static void main(String[] args) {
        try{
            method("a.txt1");
        }catch (FileAlreadyExistsException e) {
            System.out.println(e); // 默认调用的toString方法 java.nio.file.FileAlreadyExistsException: 路径不存在
            System.out.println(e.getMessage()); // 路径不存在
            System.out.println(e.toString()); // java.nio.file.FileAlreadyExistsException: 路径不存在
            e.printStackTrace();
        }finally {
            System.out.println("无论是否出现异常都会执行");
        }
    }

5、多异常捕获
格式：
try{
可能产生异常的代码1
可能产生异常的代码2
}catch(异常1 变量1) {
异常的处理逻辑
}catch(异常2 变量2) {
异常的处理逻辑
}
…
catch(异常n，变量n)
一个try多个catch注意事项：
catch里边定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上边，否则就会报错
6、子父类异常
// 如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常
// 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常，此时子类产生该异常，只能捕获，不能声明抛出
注意：
父类异常时什么样，子类异常就什么样
7、自定义异常
格式：
public class XXXEXcetion extends Exception | RuntimeException {
添加一个空参数的构造方法
添加一个带异常信息的构造方法
}
注意：
1、自定义异常类一般都是以Exception结尾，说明该类是一个异常类
2、自定义异常类，必须得继承Exception | RuntimeException
继承Exception：自定义异常类就是一个编译器异常，如果方法内部抛出了编译期异常，就必须处理这个异常，要么throws，要么try…catch
继承RuntimeException：那么自定义异常类就是一个运行期异常，无需处理，交给jvm处理即可（中断处理）
代码示例：

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

8、判断对象是否为null
// Objects中的静态方法
源码：

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

重载：（String message：异常原因）

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