十二、异常处理机制
12.1 异常处理的引入
public class Exception01 {
public static void main(String[] args) {
int num1 = 10;
int num2 = 0;
//问题：1. 执行到 int res = num1 / num2; 语句就程序异常，无法继续往下执行下一条语句
// 2. 出现一个小问题就终止程序运行，这样不好，无法保证代码的健壮性
//解决：异常捕获，选中出异常的代码 Ctrl + Alt + t ，选中 try - catch
try {
int res = num1 / num2; //ArithmeticException: / by zero
} catch (Exception e) {
//e.printStackTrace(); //这里对捕获的异常进行处理
System.out.println(e.getMessage()); //打印异常信息
}
System.out.println("程序继续运行....");
}
}
12.2 异常介绍
Java语言中，将程序执行中发生的不正常情况称为 异常。（开发过程中的语法错误和逻辑错误不是异常）
执行过程中所发生的异常事件可分为两大类：
Error（错误）：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError [栈溢出]和OOM（out of memory），Error是严重错误，程序会崩溃。Exception：其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如空指针访问，试图读取不存在的文件，网络连接中断等等，Exception分为两大类：- 运行时异常（程序运行时，发生的异常）
- 编译时异常（编程时，编译器检查出的异常）
12.3 异常体系图（重点！）
12.3.1 异常体系图
快捷键：
Ctrl + Alt + B显示实现类Ctrl + Alt + P显示父类
12.3.2 异常体系图小结
Exception分为两大类：运行时异常、编译时异常- 运行时异常， 编译器检查不出来。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。
java.lang.RuntimeException类及它的子类都是运行时异常 - 对于运行时异常， 可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响
- 编译时异常，是编译器要求 必须处置的异常。
12.4 常见的运行时异常
12.4.1 五种常见的运行时异常
NullPointerException空指针异常ArithmeticException数学运算异常ArrayIndexOutOfBoundsException数组下标越界异常ClassCastException类型转换异常NumberFormatException数字格式不正确异常
12.4.2 NullPointerException 空指针异常
介绍：当应用程序试图在需要对象的地方使用 null 时，抛出该异常
案例：
public class NullPointerException_ {
public static void main(String[] args) {
String name = null;
System.out.println(name.length()); //NullPointerException
}
}
12.4.3 ArithmeticException 数学运算异常
介绍：当出现异常的运算条件时，抛出此异常
案例：
public class ArithmeticException_ {
public static void main(String[] args) {
System.out.println(1 / 0); //ArithmeticException: / by zero
}
}
12.4.4 ArrayIndexOutOfBoundsException 数组下标越界异常
介绍：用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引
案例：
public class ArrayIndexOutOfBoundsException_ {
public static void main(String[] args) {
int[] nums = {1, 2, 3};
for (int i = 0; i
12.4.5 ClassCastException 类型转换异常
介绍：当试图将对象强制转换为不是实例的子类时，抛出该异常
案例：
public class ClassCastException_ {
public static void main(String[] args) {
A a1 = new B();
B b = (B)a1;
C c = (C)a1; //ClassCastException
}
}
class A{}
class B extends A{}
class C extends A{}
12.4.6 NumberFormatException 数字格式不正确异常
介绍：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常
案例：
public class NumberFormatException {
public static void main(String[] args) {
String name = "赵四";
int num = Integer.parseInt(name); //NumberFormatException: For input string: "赵四"
}
}
12.5 常见的编译异常
12.5.1 介绍
编译异常是指在编译期间，就必须处理的异常，否则代码不能通过编译。
12.5.2 常见的编译异常
SQLException操作数据库时，查询表可能发生异常IOException操作文件时，发生的异常FileNotFoundException当操作一个不存在的文件时，发生异常ClassNotFoundException加载类，而该类不存在时，异常EOFException操作文件，到文件末尾，发生异常IllegalArguementException参数异常
12.5.3 案例说明
public class FileNotFoundException_ {
public static void main(String[] args) {
try {
FileInputStream fis;
fis = new FileInputStream("d:\\aa.jpg");
int len;
while ((len = fis.read()) != -1) {
System.out.println(len);
}
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
12.6 异常处理
12.6.1 异常处理介绍
异常处理就是异常发生时，对异常处理的方式，有两种：
try - catch - finally：在代码中捕获异常，对异常进行处理throws： 将发生的异常抛出，返回给调用该代码的方法，最顶级的调用者是JVM
12.6.2 异常处理的示意图
12.7 try - catch 异常处理
12.7.1 try - catch 异常处理介绍
介绍：Java 提供 try 和 catch 块来处理异常。 try 块用于包含可能出错的代码。 catch 块用于处理 try 块中发生的异常。可以根据需要在程序中有多个 try..catch 块。
语法：
try {
//可能出现异常的代码
} catch (异常) {
//对捕获的异常进行处理
} finally {
//是否有异常都会执行 finally
//finally 可不写
}
12.7.2 try - catch 注意事项
- 异常发生，后面的代码不执行，直接跳到
catch代码块 - 异常没发生，不执行
catch代码块 - 不管异常发没发生，都会执行
finally代码块，一般在finally代码块进行资源释放操作
public class TryCatchDetail {
public static void main(String[] args) {
//1. 异常发生，后面的代码不执行，直接跳到 catch 代码块
//2. 异常没发生，不执行 catch 代码块
//3. 不管异常发没发生，都会执行 finally 代码块，一般在 finally 代码块进行资源释放操作
try {
String str = "111";
int a = Integer.parseInt(str);
System.out.println("数字：" + a);
} catch (NumberFormatException e) {
System.out.println("异常信息 = " + e.getMessage());
} finally {
System.out.println("finally 代码块被执行...");
}
System.out.println("程序继续...");
}
}
- 当
try代码块可能有多个异常，可以用不同的catch来捕获，分开处理（注意：子类异常捕获要写在父类异常前面）
public class TryCatchDetail2 {
public static void main(String[] args) {
//1. 当try代码块可能有多个异常，可以用不同的catch来捕获，分开处理
//2. 注意，子类异常捕获要写在父类异常前面
try {
Person person = new Person();
person = null;
System.out.println(person.getName()); //空指针异常
int n1 = 10;
int n2 = 0;
System.out.println("程序执行到此处...");
int res = n1 / n2; //算数异常
} catch (NullPointerException e) {
System.out.println("空指针异常 = " + e.getMessage());
} catch (ArithmeticException e) {
System.out.println("算术异常 = " + e.getMessage());
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Person {
private String name = "jack";
public String getName() {
return name;
}
}
- 可以进行 try-finally 配合使用, 这种用法相当于没有捕获异常，因此程序会直接崩掉/退出。
- 应用场景：就是执行一段代码，不管是否发生异常， 都必须执行某个业务逻辑
public class TryFinally_ {
public static void main(String[] args) {
//1. 可以进行 try-finally 配合使用, 这种用法相当于没有捕获异常，因此程序会直接崩掉/退出。
// 应用场景，就是执行一段代码，不管是否发生异常， 都必须执行某个业务逻辑
try {
int n1 = 10;
int n2 = 0;
System.out.println(n1 / n2);
} finally {
System.out.println("finally代码块被执行");
}
System.out.println("程序执行到此处...");
}
}
12.7.3 练习
12.7.4 try-catch-finally 执行顺序小结
- 如果没有出现异常，则执行
try块中所有语句，不执行catch块中语句，如果有finally，最后还需要执行finally里面的语句 - 如果出现异常，则
try块中异常发生后，try块剩下的语句不再执行。将执行catch块中的语句，如果有finally，最后还需要执行finally里面的语句
12.8 throws 异常处理
12.8.1 基本介绍
- 如果一个方法（中的语句执行时）可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。
- 在方法声明中用
throws语句可以声明抛出异常的 列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的 父类。
12.8.2 快速入门
public class Throws_ {
//public static void main(String[] args) throws FileNotFoundException { //可以抛出产生的异常类型
//public static void main(String[] args) throws Exception { //也可以抛出父类异常
public static void main(String[] args) throws FileNotFoundException, NullPointException { //还可以抛出多个异常
//读文件的操作可能产生FileNotFoundException类型的异常
//创建文件流对象
FileInputStream fis = new FileInputStream("d://aa.txt");
}
}
12.8.3 throws 异常处理细节
- 对于 编译异常，程序中 必须处理，比如
try-catch或者throws - 对于 运行时异常，程序中如果没有处理， 默认就是
throws的方式处理 - 子类重写父类的方法时，对抛出异常的规定：子类重写的方法，所抛出的异常类型要么和父类抛出的异常 一致，要么为父类抛出的异常的类型的 子类型
- 在
throws过程中，如果有方法try-catch，就相当于处理异常，就可以不必throws
public class ThrowsDetail {
public static void main(String[] args) {
A.methodA();
B.methodB();
}
}
//1）对于编译异常，程序中必须处理，比如try-catch 或者throws
class A {
//public void methodA() throws FileNotFoundException {
public static void methodA() /* throws FileNotFoundException */ {
//此处报编译异常，必须抛出或 try - catch
try {
FileInputStream file = new FileInputStream("d://a.txt"); //FileNotFoundException
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
//2）对于运行时异常，程序中如果没有处理，默认就是throws的方式处理
class B {
public static void methodB() /*throws NullPointerException */{
String name = "123";
name = null;
name.length(); //NullPointException 运行时异常，可不手动处理，默认会 throws NullPointException给调用处
}
}
//3）子类重写父类的方法时，对抛出异常的规定：
// 子类重写的方法，所抛出的异常类型要么和父类抛出的异常一致，
// 要么为父类抛出的异常的类型的子类型
class Father {
public void method() throws RuntimeException { }
}
class Son extends Father{
@Override
//public void method() throws Exception { //报错 此处必须为 Father 类方法抛出的异常的子类或一致
//public void method() throws FileNotFoundException { //和父类的方法抛出的异常不是父子类关系
public void method() throws RuntimeException {
}
}
//4）在throws过程中，如果有方法try-catch，就相当于处理异常，就可以不必throws，二选一
12.9 自定义异常
介绍：当程序中出现了某些”错误”，但该错误信息并没有在 Throwable 子类中描述处理，这个时候可以自己设计异常类，用于描述该错误信息。
步骤：
- 定义类：自定义异常类名（程序员自己写）继承
Exception或RuntimeException
要点：
- 如果继承
RuntimeException，属于运行异常（一般来说，继承RuntimeException，比较方便处理） - 如果继承
Exception，属于编译异常，处理比较麻烦
案例：
public class CustomException {
public static void main(String[] args) /*throws AgeException*/ { //如果自定义的异常是编译异常，处理比较麻烦
int age = 1111;
//要求范围在 18 – 120 之间，否则抛出一个自定义异常
if (age < 18 || age > 120) {
//这里可以通过构造器，设置提示信息
throw new AgeException("age必须在 18 - 20 之间"); //提示：AgeException: age必须在 18 - 20 之间
}
}
}
//自定义 AgeException 异常
//1. 一般自定义异常是继承 RuntimeException ,可以用 RuntimeException 的现有处理机制，比较方便
//2. 如果继承 Exception 就是编译异常，处理比较麻烦
public class AgeException extends RuntimeException {
//public class AgeException extends Exception {
public AgeException(String message) {
super(message);
}
}
12.10 throw 和 throws 的区别
12.11 练习
- 编写应用程序EcmDef.java，接收命令行的两个参数（整数），计算两数相除。
- 计算两个数相除，要求使用方法 cal（int n1，int n2）
- 对数据格式不正确（NumberformatException）、缺少命令行参数（ArraylndexOutOfBoundsException）、除0进行异常处理（ArithmeticException）。
Original: https://www.cnblogs.com/Carl-Zhang/p/15763042.html
Author: Carl-Zhang
Title: 十二、异常处理机制（完结）
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/685885/
转载文章受原作者版权保护。转载请注明原作者出处！