一、异常概述与异常体系结构
1.1、异常概述
在Java中，将程序执行中发生的不正常情况称为异常。Java程序在执行过程中所发生的异常事件分为两类：
- Error：Java虚拟机无法解决的严重问题；
- Exception：其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理；
对于这些错误，一般有两种解决方案：一是遇到错误时九终止程序的运行，另一种方法是有程序员在编写程序时，就考虑到错误的检测、错误的信息的提示，以及错误的处理。捕获错误最理想的是在编译期间，但有的错误只有在运行时才会发生。
1.2异常体系结构
java.lang.Throwable
|---- java.lang.Error：一般不编写针对性的代码进行处理
|---- java.lang.Exception：可以进行异常的处理
|---- 编译时异常（checked）
|---- 运行时异常（unchecked）
1.3、异常对象的生成：
- 由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出；
- 由开发人员手动创建：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样；
二、异常处理的机制
Java提供的时异常处理的抓抛模型。
-
抛：程序在正常执行过程中，一旦出现异常，就会在异常代码处生成一个对应的异常类，并将此对象抛出。一旦抛出异常对象以后，其后的代码不在执行。 -
抓：① try-catch-finally ② throws
2.1、异常处理的机制一：try-catch-finally
try{
//可能出现异常的代码
} catch(异常类型1 变量名1) {
//处理异常的方式1
} catch(异常类型2 变量名2) {
//处理异常的方式1
} catch(异常类型3 变量名3) {
//处理异常的方式3
}
……
finally {
//一定会执行的代码
}
- 使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类对象，根据此对象的类型，去catch中进行匹配；
- 一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（没有写finally的情况），继续执行其后的代码；
- catch中异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓；catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错；
- 常用的异常对象处理的方式：
- String getMessage()
- printStackTrace()
- 在try结构中声明的变量，在出了try结构以后，就不能再被调用
- 使用try-catch-finally处理编译时异常，使得程序在编译时就不会报错，但是运行时仍可能报错；
- finally是可选的；
- finally中声明的时一定会执行的代码。即使catch中由出现异常，try中有return语句，catch中有return语句等情况；
- 向数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动回收的，需要手动的进行资源的释放。此时资源的释放，就需要声明在finally中；
- 开发中，由于运行时异常比较常见，所以通常不针对运行时异常编写try-catch-finally；针对编译时异常，一定要考虑异常的处理；
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class ExceptionTest {
@Test
public void text(){
File file = null;
FileInputStream fis = null;
try {
file = new File("hello.txt");
fis = new FileInputStream(file);
int data = fis.read();
while(data != -1){
System.out.print((char)data);
data = fis.read();
}
} catch (FileNotFoundException e){
System.out.println(e.getMessage());
}catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
System.out.println("end");
}
}
2.2、异常处理的机制二：throws + 异常的类型
- "throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常。一旦方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出，异常代码后续的代码，就不在执行；
- try-catch-finally真正的将异常处理掉了；throws的方式知识将异常抛出给了方法的调用者，并没有真正将异常处理掉；
- 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
import java.io.IOException;
public class OverrideTest {
public static void main(String[] args) {
OverrideTest test = new OverrideTest();
test.display(new SubClass());
}
public void display(SuperClass s){
try {
s.method();
} catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.IOException;
public class SuperClass {
public void method() throws IOException{
}
}
import java.io.FileNotFoundException;
public class SubClass extends SuperClass{
public void method() throws FileNotFoundException {
}
}
2.3、开发中如何选择使用try-catch-finally还是使用throws
- 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理；
- 执行的方法a中，先后又调用了另外几个的方法，这几个方法是递进关系执行的。建议这几个方法是红throws的方式进行处理；而执行的方法a可以考虑try-catch-finally方式进行处理；
三、手动抛出异常：throw
public class StudentTest {
public static void main(String[] args) {
Student student = new Student();
try {
student.regist(-1001);
System.out.println(student);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
public class Student {
private int id;
public void regist(int id) throws Exception {
if (id > 0){
this.id = id;
} else {
throw new Exception("你输入的数据非法");
}
}
public String toString() {
return "Student{" + "id=" + id + '}';
}
}
四、用户自定义异常类
- 继承于现有的异常结构：RuntimeException、Exception
- 提供全局常量：serialVersionUID
- 提供重载的构造器
public class MyException extends RuntimeException {
static final long serialVersionUID = -703489719324376939L;
public MyException() {
}
public MyException(String message) {
super(message);
}
}