Throwable类

Throwable类是所有错误和异常类的超类。只有当对象是此类（或者其子类之一）的实例时，才能通过Java虚拟机或者Java throw语句抛出。类似的，只有此类或者其子类之一才可以是catch子句中的参数模型。

两个已知子类的实例，Error 和 Exception ，通常用于指示发生了异常情况。

Error属于严重问题，如内存溢出。这是不可抗力的因素。

Exception 分为编译时期异常和运行时期异常。

编译时期异常：只要不是运行时期异常统称为编译时期异常，如日期解析的时候就会产生。开发者必须得处理，否则无法编译。

运行时期异常（RuntimeException）：编译通过了，是开发者代码不严谨造成的，如空指针异常（NullPointerException）。

异常处理

异常处理方式分为两种：

①try{}catch(){}finally(){}（标准格式）：捕获异常

代码：

扫描二维码关注公众号，回复： 921033 查看本文章

public class Test1 {

	public static void main(String[] args) {
		System.out.println(getInt());
	}
	
	public static int getInt() {
		
		int a ;
		try {
			a = 10 ;
			System.out.println(a/0);
			a = 20 ;
		}catch(Exception E){
			
			a = 30 ;
			return a ;
		}finally {//finally中的语句会执行，但是最终还是会返回try-catch循环中。
			a = 40 ;//这句的作用域仅在finally中，所以finally中一般是对系统操作？
		}
		
		return a ;
	}
}

注意：如果catch中有return语句，那么finally中的代码还会执行，而且是在catch中的return之后执行一次，然后再执行finally中的语句，最后还是会执行catch中的return，返回的是catch中的语句。原因：try-catch形成的是一个环路，在执行异常处理结束时，终会返回到环路中，finally不在环路中。

② throws ：在方法上抛出异常。

变形格式：

try{}catch(){}catch(){}...

throw ：在语句中抛出一个异常对象。

格式：

throw new 异常类名() : 匿名对象的方式

标准格式 try{ ... }catch(异常类对象){ // 异常处理 } 执行try里面的代码
,如果出现了问题,它会通过代码的问题创建一个异常对象,然后通过异常对象和catch里面的异常类是否一致
如果一致的情况,就会出现catch里面的代码,执行Throwable里面的方法

多个异常怎么办？

有多少异常就捕捉（catch）多少异常。当然也可以写多个try catch语句。

Jdk7以后出现另一种方式处理多个异常

try{
可能出现问题的代码;
}catch(异常类名1 | 异常类名2 |... 对象名){

处理异常

}

常见异常：

java.lang.ArithmeticException 算数异常

ArrayIndexOutOfBoundsException 数组角标越界

ParseException 解析异常

Throwable中的方法

public String getMessage() :消息字符串

public String toString(): 异常的简短描述

public void printStackTrace()：返回值void 直接调用, 包含了消息字符串,还有": "

throws 和 throw 的区别

throws表示抛出异常，后面跟的是异常类名，并且可以跟多个异常类名，用逗号隔开。这种抛出机场的方式由调用者处理，表示抛出异常的可能性。

例如：

public void show() throws IoException,ClassNotFoundException{...}

throw抛出的是一个异常对象，在语句中抛出，由语句体进行处理，表示抛出异常的肯定性。

自定义异常类

import java.util.Scanner;

public class Test2 {

	public static void main(String[] args) throws DefineException {
		System.out.println("输入成绩：");
		Scanner sc = new Scanner(System.in) ;
		int score = sc.nextInt();
		Check.check(score);
	}
}

/**
 * 只是一个自定义的异常类，这个类继承自Exception类，并且自己写了有参构造
 * @author malaganguo
 *
 */
class DefineException extends Exception{

	public DefineException() {
		super();
	}

	public DefineException(String message) {
		super(message);
	}
	
}
/**
 * 这是一个校验类，若不满足需求，抛出异常
 * @author malaganguo
 *
 */
class Check {
	
	public static void check(int score) throws DefineException {
		if(score > 100 || score < 0) {//如果录入的成绩越界了，抛出异常
			throw new DefineException("这个成绩有问题！") ;//抛出一个匿名对象
		}else {
			System.out.println("成绩录入成功");
		}
		
	}
}

结果：

异常中的注意事项:

子类继承父类的时候的注意事项

1)子类重写父类的方法的时候,子类的方法的抛出的异常必须要么是父类的方法异常一样,要么是父类方法异常的子类

2)子类重写父类方法的时候,如果父类中的这个方法没有抛出异常,那么子类重写的这个方法也不能抛出异常,只能try...catch

文件中的多异常处理

下面是开发中最常用的多异常处理：

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

public class Test {

	public static void main(String[] args) {

		// 定义一个输出流类型变量
		FileOutputStream fos = null;
		/**
		 * 因为我们在创建fos对象的时候可能产生异常。，所以在写操作、关资源的时候因为需要使用对象，所以都会产生异常
		 * 我们对于多异常的处理方式：alt+Shift+z 选则try/catch block进行多异常处理
		 * 这是最常用的多一场处理方式
		 */
		try {
			fos = new FileOutputStream("fosexc.txt");
			fos.write("hello".getBytes());
			fos.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// 释放资源前对对象进行非空判断
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

JavaSE——day15异常类