【Java基础】异常处理
异常处理
异常概述
在 Java 语言中，将程序执行中发生的不正常情况称为“异常”，但是开发过程中的语法错误和逻辑错误不是异常。
在执行过程中所发生的异常事件可分为两类：
- Error：JVM 无法解决的严重问题，一般不编写针对性的代码进行处理。例如：
- StackOverflowError；
- OutOfMemoryError
- Exception：它因编程错误或偶然的外在因素导致的一般性问题，可以使
用针对性的代码进行处理。例如：- 空指针访问；
- 试图读取不存在的文件；
- 网络连接中断；
- 数组下标越界。
捕获错误最理想的是在编译期间，但有的错误只有在运行时才会发生。所以异常分为编译时异常和运行时异常。
编译时时异常：
- 是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。
- 对于这类异常，如果程序不处理，可能会带来意想不到的结果。
运行时异常：
- 是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。
java.lang.RuntimeException类及它的子类都是运行时异常。 - 对于这类异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响。
常见异常
常见异常：
java.lang.RuntimeException- ClassCastException；
- ArrayIndexOutOfBoundsException；
- NullPointerException；
- ArithmeticException；
- NumberFormatException；
- InputMismatchException；
- ...
java.io.IOExeption- FileNotFoundException；
- EOFException；
java.lang.ClassNotFoundException；java.lang.InterruptedException；java.io.FileNotFoundException；java.sql.SQLException；
try-catch-finally
在编写程序时，经常要在可能出现错误的地方加上检测的代码，可能出现过多的 if-else 分支会导致程序的代码加长、臃肿，可读性差。因此采用异常处理机制。
Java 采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁、优雅，并易于维护。
Java 异常处理的方式：
- try-catch-finally;
- throws + 异常类型。
Java 提供的是异常处理的抓抛模型。Java程序的执行过程中如果出现异常，会生成一个异常类对象，该异常对象将被提交给 Java 运行时系统，这个过程称为抛出（throw）异常。如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这个过程称为捕获（catch）异常。
其中，“抛”，可以理解为异常对象的产生，有 1. 系统自动生成的异常对象 和 2. 手动的生成的一个异常对象，并 throw。
其中，“抓”，可以理解为异常的处理方式，有 1. try-catch-finally 和 2. throws 。
异常对象的生成：
- 由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出 —— 自动抛出。
- 由开发人员手动创建：
Exception exception = new ClassCastException();—— 创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样。
与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法：
getMessage()获取异常信息，返回字符串；printStackTrace()获取异常类名和异常信息，以及异常出现在程序中的位置，返回值 void。
语法格式：
try {
// 可能产生异常的代码
} catch (ExceptionName1 e) {
// 可选的，处理ExceptionName1型异常
} catch (ExceptionName2 e) {
// 可选的，处理ExceptionName2型异常
} [ finally {
// 可选的，无论是否发生异常，都无条件执行的语句
}]
注意：
- catch 中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。如果有子父类关系，则要求子类一定声明在父类的上面，否则报错。
- 在 try 结构中声明的变量，在出了 try 结构以后，就不能再被调用。
- 像数据库连接、输入输出流、网络编程 Socket 等资源，JVM 是不能自动回收的，需要自己手动的进行资源的释放，此时的资源释放，就需要声明在 finally 中;
package com.parzulpan.java.ch04;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/**
* @Author : parzulpan
* @Time : 2020-11-22
* @Desc : 异常处理机制：try-catch-finally
*/
public class ExceptionTest {
public static void main(String[] args) {
// 最初版
// try {
// File file = new File("hello.txt");
// FileInputStream fileInputStream = new FileInputStream(file);
//
// int data = fileInputStream.read();
// while (data != -1) {
// System.out.println((char) data);
// data = fileInputStream.read();
// }
// fileInputStream.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// 改进版
FileInputStream fileInputStream = null;
try {
File file = new File("hello.txt");
fileInputStream = new FileInputStream(file);
int data = fileInputStream.read();
while (data != -1) {
System.out.println((char) data);
data = fileInputStream.read();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fileInputStream != null) {
fileInputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
不捕获异常时的情况：
- 对于运行时异常，例如 RuntimeException 类或是它的子类等，这些类的异常的特点是：即使没有使用 try 和 catch 捕获，Java 自己也能捕获，并且编译通过，但运行时会发生异常使得程序运行终止。
- 对于编译时异常，例如 是IOException 等，则必须捕获，否则编译错误。
- 必须处理编译时异常，将异常进行捕捉，转化为运行时异常。
throws
如果一个方法（中的语句执行时）可能生成某种异常，但是并不能确定如何处理这
种异常，则此方法应显式地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。
在方法声明中用 throws 语句可以声明抛出异常的列表，throws 后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。
package com.parzulpan.java.ch04;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/**
* @Author : parzulpan
* @Time : 2020-11-22
* @Desc : 异常处理机制：throws + 异常类型
*/
public class ExceptionTest1 {
public static void main(String[] args) {
try {
method();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void method() throws IOException {
File file = new File("hello.txt");
FileInputStream fileInputStream = new FileInputStream(file);
int data = fileInputStream.read();
while (data != -1) {
System.out.println((char) data);
data = fileInputStream.read();
}
fileInputStream.close();
}
}
注意：try-catch-finally 是真正的将异常给处理掉了，而 throws 的方式只是将异常抛给了方法的调用者，并没有真正的将异常处理掉。
重写方法声明抛出异常的原则：
- 重写方法不能抛出比被重写方法范围更大的异常类型。这是因为多态性存在的缘故。
try-catch-finally 和 throws 的选择：
- 如果父类中被重写的方法没有 throws 处理异常，则子类重写的方法也不能使用 throws。意味着如果子类重写的方法中有异常，必须使用 try-catch-finally 处理异常。
- 执行的方法 A 中，先后又调用另外几个方法，这几个方法是递进关系执行的，建议这几个方法使用 throws 处理异常，而 方法 A 可以使用 try-catch-finally 处理异常。
throw
Java 异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要使用人工创建并抛出。
首先要生成异常类对象，然后通过 throw 语句实现抛出操作（提交给 Java 运行环境），可以抛出的异常必须是 Throwable 或其子类的实例：
IOException e = new IOException();
throw e;
package com.parzulpan.java.ch04;
/**
* @Author : parzulpan
* @Time : 2020-11-22
* @Desc : 手动抛出异常
*/
public class ExceptionTest2 {
public static void main(String[] args) {
// StudentAA studentAA = new StudentAA();
// studentAA.add(-10);
// System.out.println(studentAA); // 请输入的数据非法！StudentAA{id=0}
try {
StudentAA studentAA = new StudentAA();
studentAA.add(-10);
System.out.println(studentAA); // 请输入的数据非法！
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
class StudentAA {
private int id;
public void add(int id) throws Exception{
if (id > 0) {
this.id = id;
} else {
// System.out.println("请输入的数据非法！");
// 手动抛出异常
throw new Exception("请输入的数据非法！");
}
}
@Override
public String toString() {
return "StudentAA{" +
"id=" + id +
'}';
}
}
自定义异常类
注意：
- 一般地，用户自定义异常类都是 RuntimeException/Exception 的子类；
- 自定义异常类通常需要编写几个重载的构造器；
- 自定义异常需要提供 serialVersionUID；
- 自定义的异常通过 throw 抛出；
- 自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型。
package com.parzulpan.java.ch04;
/**
* @Author : parzulpan
* @Time : 2020-11-22
* @Desc : 用户自定义异常类
*/
public class MyExceptionTest {
public static void main(String[] args) {
MyExceptionTest myExceptionTest = new MyExceptionTest();
myExceptionTest.manager();
}
public void add(int num) throws MyException{
if (num < 0) {
throw new MyException("人数为负值，不合理", 3);
} else {
System.out.println("登记人数 " + num);
}
}
public void manager() {
try {
add(-10);
} catch (MyException e) {
System.out.println(e.getMessage());
System.out.println("登记失败，出错种类 " + e.getId());
}
System.out.println("本次登记操作结束");
}
}
class MyException extends Exception {
static final long serialVersionUID = 2165326351631265L;
private int id;
public MyException(String msg, int id) {
super(msg);
this.id = id;
}
public int getId() {
return id;
}
}
练习和总结
判断程序的输出结果？
public class ReturnExceptionDemo {
static void methodA() {
try {
System.out.println("进入方法A"); // 1
throw new RuntimeException("制造异常"); // 2
} finally {
System.out.println("用A方法的finally"); // 3
}
}
static void methodB() {
try {
System.out.println("进入方法B"); // 4
return;
} finally {
System.out.println("调用B方法的finally"); // 5
}
}
public static void main(String[] args) {
try {
methodA();
} catch (Exception e) {
System.out.println(e.getMessage());
}
methodB();
}
}
输出：1 -> 3 -> 2 -> 4 -> 5
