java学习14

异常

异常概念

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

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象，Java处理异常的方式是中断处理。

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

异常体系

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

异常分类

java.lang.Throwable类是Java语言中所有错误或异常的超类

	Exception：编译期异常，进行编译Java程序出现的问题
		RuntimeException：运行期异常，Java程序运行过程中出现的问题。
		异常处理掉，程序可以正常执行。

	Error：错误
		错误必须修改源代码，程序才能继续执行。

异常的处理

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

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

使用格式：

throw new XXXException("异常产生的原因");

注意：

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

public class Demo01Throw {
	
	public static void main(String[] args) {
		
//		int[] arr = null;
//		getElement(arr, 0);
		int[] arr = {1,2};
		getElement(arr, 6);

		
	}

	/*
	 * 定义一个方法，获取指定索引处的元素
	 * 对方法传递过来的参数进行合法性校验
	 * 如果参数不合法，使用抛出异常的方式，告知方法的调用者，传递的参数有问题
	 * 注意：
	 * 	NullPointerException是运行期异常，我们不用处理，默认交给JVM处理
	 */
	public static int getElement(int[] arr,int index) {
		/*
		 * 对传递过来的参数数组进行合法性校验
		 * 若arr的值是null，抛出空指针异常，告知方法的使用者“传递的数组值是空”
		 */
		if(arr == null) {
			throw new NullPointerException("传递的数组值是null");
			/*Exception in thread "main" java.lang.NullPointerException: 传递的数组值是null
			 * 		at Demo12.Demo01Throw.getElement(Demo01Throw.java:28)
			 * 		at Demo12.Demo01Throw.main(Demo01Throw.java:8)
			 */
	
		}
		/*
		 * 对传递过来的参数index进行校验
		 * 若index的范围不在数组的索引范围内，抛出数组索引越界异常，告知调用者“传递的索引超出了数组的使用范围”
		 */
		if(0 > index || index > arr.length - 1) {
			throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
			/*Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 传递的索引超出了数组的使用范围
			 * 		at Demo12.Demo01Throw.getElement(Demo01Throw.java:40)
			 * 		at Demo12.Demo01Throw.main(Demo01Throw.java:10)
			 */
		}
		int ele = arr[index];
		return ele;
	}
}

Objects非空判断

public static <T> T requireNonNull(T obj)
【查看指定引用对象是不是null】

import java.util.Objects;

public class Demo02Objects {
	
	public static void main(String[] args) {
		method(null);
	}
	
	public static void method(Object obj) {
		//对传递过来的参数进行合法性判断，判断是否为null
//		if(obj == null) {
//			throw new NullPointerException("传递的对象的值是null");
//			/*Exception in thread "main" java.lang.NullPointerException: 传递的对象的值是null
//			 *		at Demo12.Demo02Objects.method(Demo02Objects.java:12)
//			 * 		at Demo12.Demo02Objects.main(Demo02Objects.java:6)
//			 */
//		}
		
//		Objects.requireNonNull(obj);
		Objects.requireNonNull(obj, "传递的对象的值是null");//重载
	}

}

throws关键字
声明异常：将问题标识出来，报告给调用者，如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。

throws关键字的作用：

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

使用格式：在方法声明时使用

修饰符 返回值类型 方法名(参数列表) throws AAAException,BBBException...{
	throw new AAAException("产生原因");
	throw new BBBException("产生原因");
}

注意：

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

import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo03Throws {
	
	public static void main(String[] args) throws IOException {
		/*
		 * 注意：FileNotFoundException extends IOException
		 */
		readFile("c:\\a.tx");
	}

	/* 定义一个方法对传递的文件路径进行判断
	 * 若路径不是“c:\\a.txt”,抛出文件找不到异常，告知方法的调用者
	 * 注意：
	 * 		FileNotFoundException是编译期异常，抛出了编译异常就必须处理
	 * 		可以使用throws继续声明抛出FileNotFoundException这个异常对象，让方法的调用者处理
	 */
	public static void readFile(String fileName) throws IOException {
		if(!fileName.equals("c:\\a.txt")) {
			throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
			/*Exception in thread "main" java.io.FileNotFoundException: 传递的文件路径不是c:\a.txt
			 * 		at Demo12.Demo03Throws.readFile(Demo03Throws.java:18)
			 * 		at Demo12.Demo03Throws.main(Demo03Throws.java:8)
			 */
	
		}
		
		/* 如果传递的路径不是 .txt 结尾
		 * 那就抛出IO异常对象，告知方法的调用者，方法的后缀名不对
		 */
		if(fileName.endsWith(".txt")) {
			throw new IOException("文件的后缀名不对");
		}
		
		
		System.out.println("文件没有问题，读取文件");
	}
}

捕获异常try…catch
try…catch：异常处理的第二种方式

格式：

try{
	可能产生异常的代码
}catch(定义一个异常的变量，用来接收try中抛出的异常对象){
	异常的处理逻辑，如何处理异常对象
	（一般会记录在日志中）
}..
..catch(异常类名 变量名){
}

注意：

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

import java.io.IOException;

public class Demo04TryCatch {
	
	public static void main(String[] args) {
		try {
			readFile("c:\\c.tx");
		}catch(IOException e) {
			System.out.println("catch-文件后缀名不是.txt");
		}
		System.out.println("后续代码");
	}
	
	public static void readFile(String fileName) throws IOException {
		if(fileName.endsWith(".txt")) {
			throw new IOException("文件后缀名不对");
		}
		System.out.println("文件名没有问题，后续代码");
	}

}

Throwable类
Throwable定义了一些查看方法

public String getMessage()
【返回此throwable的简短描述】
【System.out.println(e.getMessage());】

public String toString()
【返回此throwable的详细消息字符串】
【System.out.println(e.toString());】

public void printStrackTrace()
【打印异常的跟踪栈信息并输出到控制台（最全面）】
【包含了异常的类型、原因、位置，在开发和调试阶段都得使用printStrackTrace】
【e.printStrackTrace()】

finally代码块
格式：

try{
	可能产生异常的代码
}catch(定义一个异常的变量，用来接收try中抛出的异常对象){
	异常的处理逻辑，如何处理异常对象
	（一般会记录在日志中）
}..
..catch(异常类名 变量名){
}finally{
	无论是否出现异常都会执行
}

注意：

1.finally能单独使用，必须和try一起使用
2.finally一般用于资源释放（资源回收），无论程序是否出现异常最后都要资源释放

异常注意事项

多异常的捕获处理

1.多个异常分别处理

2.多个异常一次捕获，多次处理
	
	【一个try多个catch注意事项：】
		catch里面定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上边，否则就会报错。
		
3.多个异常一次捕获，一次处理

运行时异常被抛出可以不处理，即不捕获也不声明抛出。默认给虚拟机处理，终止程序，什么时候不抛出运行时异常了，再继续执行程序。

import java.util.ArrayList;

public class Demo05Exception {
	
	public static void main(String[] args) {
		
		//多次捕获多次处理
		try {
			int[] arr = {1,2,3};
			System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
		}catch(ArrayIndexOutOfBoundsException e) {
			System.out.println(e);
		}

		try {
			ArrayList<Integer> list = new ArrayList<>();
			list.add(1);
			list.add(2);
			list.add(3);
			System.out.println(list.get(3));//IndexOutOfBoundsException
		}catch(IndexOutOfBoundsException e) {
			System.out.println(e);
		}
		
		//一次捕获多次处理
		try {
			int[] arr = {1,2,3};
			System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
			
			ArrayList<Integer> list = new ArrayList<>();
			list.add(1);
			list.add(2);
			list.add(3);
			System.out.println(list.get(3));//IndexOutOfBoundsException
		}catch(ArrayIndexOutOfBoundsException e) {
			System.out.println(e);
		}catch(IndexOutOfBoundsException e) {
			System.out.println(e);
		}
		
		//一次捕获一次处理
		try {
			int[] arr = {1,2,3};
			System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
			
			ArrayList<Integer> list = new ArrayList<>();
			list.add(1);
			list.add(2);
			list.add(3);
			System.out.println(list.get(3));//IndexOutOfBoundsException
		}catch(IndexOutOfBoundsException e) {
			System.out.println(e);
		}
		
	}

}

finally有return语句

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

子父类异常

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

自定义异常类

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

格式：

public class XXXException extends Exception/RuntimeException{
	定义一个空参构造方法
	定义一个带异常信息构造方法
}

注意：

1.自定义异常类一般都是以Exception结尾，说明该类是一个异常类。
2.自定义异常类必须继承Exception或者RuntimeException
	继承Exception：自定义异常类是编译期异常，若内部方法抛出了编译期异常就必须处理，要么throws要么try...catch
	继承RuntimeException：自定义异常类是运行期异常，无需处理，交给虚拟机处理（中断处理）

public class Demo06Exception extends Exception{

	public Demo06Exception() {
		super();
	}
	
	public Demo06Exception(String message) {
		super(message);
	}
	
}