Javase-day16-异常

一、异常

异常：程序在运行中，出现非正常的情况，最终会导致JVM的非正常停止。
在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象，Java处理异常的方式是中断处理。

异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.

1、异常体系

异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，通常我们所说的异常指的是java.lang.Exception。

Throwable体系：

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

Throwable类的成员方法

• public void printStackTrace()：打印异常的详细信息。

  包含了异常的类型,异常的原因，还包括异常出现的位置，在开发和调试阶段，都得使用 printStackTrace。

• public String getMessage()：获取发生异常的原因。

  提示给用户的时候，就提示错误原因。

• public String toString()：获取异常的类型和异常描述信息(不用)。

2、异常分类

编译时异常与运行时异常的区别

java.lang.Throwable：是Java中所有【错误】或【异常】的父类
　　Execption：编译期异常，进行编译（写代码）时java程序出现的问题
　　　其中的一个子类RuntimeException：运行期异常，Java程序运行过程中出现的问题
　　　异常就相当于程序得了一个小毛病，把异常处理掉，程序就可以继续执行。
　　Error：错误
　　　错误就相当于程序得了绝症，必须要修改源代码，程序才能继续执行

// Exception：编译期异常，写代码的时候发生
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = null;
try {
	date = sdf.parse("1999-0909");
} catch (ParseException e) {
	e.printStackTrace();
}
System.out.println(date);
System.out.println("后续代码");

// RuntimeException：运行期异常，Java程序运行过程中出现的问题
int[] arr = {1,2,3};
try {	
	// 可能会出现异常的代码
System.out.println(arr[3]);
} catch(Exception e) {
	// 异常的处理逻辑
	System.out.println("后续代码");
}

// Error : 错误
int[] arr = new int[1024 * 1024 * 1024];
	// OutOfMemoryError: Java heap space	内存溢出的错误,创建的数组太大了,超出了给JVM分配的内存
	//必须要改源代码，让数组小一点

3、异常的产生过程解析

二、异常的处理

0、JVM的默认处理方案

Java的默认处理会让程序直接结束掉不会往下执行了，在实际应用中不可取，所以我们要自己来处理异常。

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

1、throw关键字

作用：
　　可以使用throw关键字在【指定的方法】中抛出指定的异常
使用格式：
　　throw　new　xxxxException(“异常产生的原因”)；

注意：

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

NullPointerException是一个运行期异常,我们不用处理,默认交给JVM处理
ArrayIndexOutOfBoundsException也是一个运行期异常,我们不用处理,默认交给JVM处理

public class Demo03Throw {
    public static void main(String[] args) {
        // int[] arr = null;
        int[] arr = new int[3];
        int e = getElement(arr,3);
        System.out.println(e);
    }
    /*
        定义一个方法,获取数组指定索引处的元素
        参数:
            int[] arr
            int index
        以后(工作中)我们首先必须对方法传递过来的参数进行合法性校验
        如果参数不合法,那么我们就必须使用抛出异常的方式,告知方法的调用者,传递的参数有问题
        注意:
            NullPointerException是一个运行期异常,我们不用处理,默认交给JVM处理
            ArrayIndexOutOfBoundsException是一个运行期异常,我们不用处理,默认交给JVM处理
*/
    public static int getElement(int[] arr,int index){
        /*
            我们可以对传递过来的参数数组,进行合法性校验
            如果数组arr的值是null
            那么我们就抛出空指针异常,告知方法的调用者"传递的数组的值是null"
       */
        if(arr == null){
            throw new NullPointerException("传递的数组的值是null");
        }
        
        /*  我们可以对传递过来的参数index进行合法性校验
            如果index的范围不在数组的索引范围内
            那么我们就抛出数组索引越界异常,告知方法的调用者"传递的索引超出了数组的使用范围"
        */
        if(index < 0 || index > arr.length-1){
            throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
        }
        int ele = arr[index];
        return ele;
    }
}

2、Objects非空判断

Objects类，由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或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;
}

应用：
public class Demo04Objects {
    public static void main(String[] args) {
        method(null);
    }
    public static void method(Object obj){
        // 对传递过来的参数进行合法性判断, 判断是否为null
        /*
        if(obj == null){
            throw new NullPointerException("传递的对象的值是null");
        }
        */
		// 直接用Objects中的静态方法【requireNonNull】判断对象是否为空，简化代码
        Objects.requireNonNull(obj,"传递的对象的值是null");
    }
}

3、捕获异常try…catch

只有try…catch能在处理异常后，还继续执行程序。

格式：
try {
	可能出现异常的代码;
} catch(异常类名 变量名) {
	异常的处理代码;
}

演示：
// 在method方法中
public static void method() {
	try{
		int[] arr = {1, 2, 3};
		System.out.println(arr[3]);	// 这里出错了就相当于new了一个对象——new ArrayIndexOfBoundException();
	} catch(ArrayIndexOutOfBoundException e){
		e.printStackTrace();
	}
}

4、throws关键字

throws仅仅是把异常抛出去，没有做到自己处理（还要调用方法者来处理最后给JVM处理），会直接中断程序，如果想让程序继续往下执行，还得用try…catch

throws只起到抛出异常的作用，真正的处理还是得靠try…catch

throw与throws的区别

5、finally代码块

格式：

try…catch…finally…

finally语句中的代码一定会被执行，不管try、catch语句中有没有return s(表达式) 之类的语句，而且如果finally语句中有return s（不推荐），不会影响到try…catch中return的值。
可以看下这篇try…catch相关的描述

异常的注意事项

• 多个异常使用捕获又该如何处理呢？

  1. 多个异常分别处理。
  2. 多个异常一次捕获，多次处理。
  3. 多个异常一次捕获一次处理。

  一般我们是使用一次捕获多次处理方式，格式如下：

  try{
       编写可能会出现异常的代码
  } catch (异常类型A  e) {  当try中出现A类型异常,就用该catch来捕获.
       处理异常的代码
       // 记录日志/打印异常信息/继续抛出异常
  } catch (异常类型B  e) {  当try中出现B类型异常,就用该catch来捕获.
       处理异常的代码
       // 记录日志/打印异常信息/继续抛出异常
  }
  

  注意 : 这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

• 运行时异常被抛出可以不处理。即不捕获也不声明抛出。

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

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

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

三、自定义异常