异常

 Java代码在运行时期发生的问题就是异常。

在Java中，把异常信息封装成了一个类。当出现了问题时，就会创建异常类对象并抛出异常相关的信息（如异常出现的位置、原因等）。

1异常的继承体系

1.1使用Exception类来描述异常。

 

Exception的父类是Throwable。

Throwable是Java 语言中所有错误或异常的超类，即祖宗类。

 

1.2特殊子类：RuntimeException子类

RuntimeException及其它的子类只能在Java程序运行过程中出现。

 

1.3 Error

与异常Exception平级的有一个Error，它是Throwable的子类，它用来表示java程序中可能会产生的严重错误。解决办法只有一个，修改代码避免Error错误的产生。

 

异常继承体系总结：

Throwable: 它是所有错误与异常的超类（祖宗类）

|- Error 错误

|- Exception 编译期异常,进行编译JAVA程序时出现的问题

|- RuntimeException 运行期异常, JAVA程序运行过程中出现的问题

 

2异常与错误的区别

例1：

 

 

一般第一个位置是主要原因。

例2：

 

内存溢出错误：

 

异常：感冒发烧，是可以治的。可以对异常进行具体的处理。若不处理异常，程序将会结束运行。

错误：癌症，艾滋病，是不能治的，一旦发生错误，无法针对处理，只能修改代码。

3异常产生的过程

1）Jvm检测到异常，然后创建一个异常对象，

2）将该对象向上抛出，抛给调用者，

3）调用者接收到异常后，如果不能处理，就继续向上抛，抛给调用者，（到达main方法，最后到达jvm），

4）如果最后抛给了jvm，就将该异常对象及信息以红字的形式打印到控制台，并终止程序 

注意：一旦产生异常，下面的代码将不再执行。 

图说明：

 

4抛出异常throw

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。 

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。

使用格式：

throw new 异常类名(参数);

5声明异常throws

声明：将问题标识出来，报告给调用者。

声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2… {   } 

例:（把异常发给jvm，一般不这样，因为会终止程序）

public class Test2 {
	public static void main(String[] args) throws Exception{
		int[] arr={};
		int i=get(arr);
		System.out.println(i);
	}
	
	//抛异常
	public static int get(int[] arr) throws Exception{
		if(arr.length==0){
			throw new Exception("传入空数组");
		}
		if(arr==null){
			throw new Exception("传入数组为null");
		}
		
		int i=arr[arr.length-1];
		return i;
	}
}

6捕获异常（调用者处理）

捕获：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理

捕获异常格式：

try {

//需要被检测的语句。

}

catch(异常类 变量) { //参数。

//异常的处理语句。

}

finally {

//一定会被执行的语句。

}

try：该代码块中编写可能产生异常的代码。

catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。（可以不写） 

例：

public class Test3 {
	public static void main(String[] args){
		int[] arr={};
		
		try{
			int i=get(arr);
			System.out.println(i);
		}catch(Exception ex){
			System.out.println(ex);
		}finally{
			System.out.println("一定会执行的代码");
		}
		
		System.out.println("异常外的代码");
	}
	
	public static int get(int[] arr) throws Exception{
		if(arr.length==0){
			throw new Exception("不能传入空数组");
		}
		if(arr==null){
			throw new Exception("传入数组为null");
		}
		
		int i=arr[arr.length-1];
		return i;
	}
}

 

ex可以理解为形参，就是把new Exception传进来

注意：

1）有多个异常，就要写多个catch块

2）捕获时要有顺序，父类写在后面

例：

选中类，ctrl+T：

 

7异常处理的组合方式

try catch finally组合：检测异常，并传递给catch处理，并在finally中进行资源释放。 

try catch组合 : 对代码进行异常检测，并对检测的异常传递给catch处理。对异常进行捕获处理。（组合块以外的代码还会执行） 

一个try 多个catch组合 : 对代码进行异常检测，并对检测的异常传递给catch处理。对每种异常信息进行不同的捕获处理。

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

try  finally 组合: 对代码进行异常检测，检测到异常后因为没有catch，所以一样会被默认jvm抛出。异常是没有捕获处理的。但是功能所开启资源需要进行关闭，所有finally。只为关闭资源。（组合块以外的代码不会执行）

 

8运行时期异常

编译时期异常：Exception及其子类（但不包括RuntimeException和其子类）

运行时期异常：RuntimeException和其子类 

RuntimeException和他的所有子类异常,都属于运行时期异常。

NullPointerException,ArrayIndexOutOfBoundsException等都属于运行时期异常。

特点：

方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常，

运行时期异常一旦发生,需要程序人员修改源代码。 

例：没有报红（错误）

编译失败，因为parse方法里面定义并抛出了异常。查看一下：

 

这时有两种处理方式：

1thorws，2try 

可以直接点出来：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTest {
	public static void main(String[] args) {
		SimpleDateFormat sdf=new SimpleDateFormat("");
		try {
			Date d=sdf.parse("2018年11月11日");
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("异常外的代码");
	}
}

就不会编译失败了

e.printStackTrace();这个方法就是打印jvm的信息，但不会终止程序 

 

实际应用：当遇到jdk里面一些类的异常时，如果编译失败，那么会处理就可以（两种方式）。

 

9异常在方法重写中细节

1）如果父类方法抛出异常，子类继承父类重写该方法时，要么不抛出异常，如果抛，必须抛父类方法抛出的异常或其子类。

  

2）如果父类方法没有抛出异常，那么子类继承父类重写该方法时，不允许抛出任何异常。

 

这时，只能用try

 

10异常中常用方法

getMessage方法：返回该异常的简短描述

toString方法：返回该异常的名称与详细信息字符串

printStackTrace：在控制台输出该异常的名称与详细信息字符串、异常出现的代码位置，红字打印异常信息（最常用）

例：

public class Test1 {
	public static void main(String[] args) {
		int[] arr={};
		int i=0;
		try {
			i = get(arr);
		} catch (Exception e) {	
			System.out.println(e.getMessage());
			System.out.println(e.toString());
			e.printStackTrace();			
		}
		System.out.println(i);
	}
	
	public static int get(int[] arr) throws Exception{
		if(arr.length==0){
			throw new Exception("数组为空");
		}
		return arr.length-1;
	}
}

11自定义异常

可以模拟Java的这种机制，我们自己定义异常的信息，异常的名字，让异常更符合自己程序的阅读。准确对自己所需要的异常进行类的描述。

例：

public class FuShuException extends RuntimeException{
	public FuShuException(){
		
	}
	public FuShuException(String str){
		super(str); //调用父类构造，并传入参数
	}
}

public class ScoreTest {
	public static void main(String[] args) {
		int[] arr={1,2,-3,4,5};
		double score=avg(arr);
		System.out.println(score);
	}
	//求学生平均成绩
	public static double avg(int[] arr){
		int sum=0;
		for(int i:arr){
			if(i<0){
				throw new FuShuException("传入的数组中有负数"+i);
			}
			sum+=i;
		}
		return sum/arr.length;
	}
}