第三章：java的异常

系列文章目录

---

---

前言

程序有时会有一些小问题，为了避免程序直接退出，可以使用异常来处理。

---

一、异常

java语言中奖程序中发生的不正常情况称为”异常“。（开发过程中的语法错误和逻辑错误不是异常）

异常事件
Error（错误）：java虚拟机无法解决的严重问题。比如：JVM系统内部错误、资源耗尽等严重情况
Exception：其他因编程错误或偶然的外部因素导致的一般性问题，可以使用针对性的代码进行处理。比如：空指针访问、试图读取不存在的文件、网络连接中断等

Exception
运行时异常：运行时发生的异常
编译时异常：编程时编译器检查出的异常

public class Exception01 {

	public static void main(String[] args) {
		int num1 = 10;
		int num2 = 0;//Scanner();
		//老韩解读
		//1. num1 / num2 => 10 / 0
		//2. 当执行到 num1 / num2 因为 num2 = 0, 程序就会出现(抛出)异常 ArithmeticException
		//3. 当抛出异常后， 程序就退出， 崩溃了 , 下面的代码就不在执行
		//4. 大家想想这样的程序好吗? 不好， 不应该出现了一个不算致命的问题， 就导致整个系统崩溃
		//5. java 设计者， 提供了一个叫 异常处理机制来解决该问题
		// int res = num1 / num2;
		//如果程序员， 认为一段代码可能出现异常/问题， 可以使用 try-catch 异常处理机制来解决
		//从而保证程序的健壮性
		//将该代码块->选中->快捷键 ctrl + alt + t -> 选中 try-catch
		//6. 如果进行异常处理， 那么即使出现了异常， 程序可以继续执行
		try 
		{
			int res = num1 / num2;
		} 
		catch (Exception e) 
		{
			//e.printStackTrace();
			System.out.println("出现异常的原因=" + e.getMessage());//输出异常信息
		}
		System.out.println("程序继续运行....");
	}
}

异常体系图
异常分为两大类，运行时异常和编译时异常
运行时异常编译器查不出来。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常
对于运行时异常可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产出影响
编译时异常，是编译器要求必须处置的异常

1.1 常见运行时异常

常见运行时异常	含义
NullPointerException	空指针异常
ArithmeticException	数学运算异常
ArrayIndexOutOfBoundsException	数组下标越界异常
ClassCastException	类型转换异常
NumberFormatException	数字格式不正确异常

1.2 常见编译时异常

常见编译时异常	含义
SQLException	操作数据库时查询表可能发生异常
IOException	操作文件时发生的异常
FileNotFoundException	当操作一个不存在的文件时发生的异常
ClassNotFoundException	加载类而该类不存在时发生的异常
EOFException	操作文件到文件末尾发生的异常
IllegalArguementException	参数异常

二、异常处理

异常处理就是当异常发生时，对异常处理的方式。

异常处理方式
try-catch-finally：程序员在代码中捕获发生的异常，自行处理
throws：程序员将发生的异常抛出，交给调试者（方法）来处理，最顶级的处理者就是JVM

2.1 try-catch 异常处理

//语法形式
try
{
	可能发生异常的代码
}
catch(Exception e)
{
	1.当异常发生时系统将异常封装成Exception对象e,传递给catch
	2.得到异常对象后程序员自己处理
	3.注意如果没有发生异常则catch代码块不执行
}
finally
{
	1.不管try代码块是否有异常发生始终要执行finally，所以通常释放资源的代码放在这里
	2.如果没有finally，语法也是可以通过的
}

public static void main(String[] args) {
	int num1 = 10;
	int num2 = 0;
	try {
		int res = num1 / num2;
	} catch (Exception e) {
		System.out.println(e.getMessage());
	} 
}

try-catch方式处理异常使用细则
如果异常发生了则异常发生后面的代码不会执行直接进入catch块
如果异常没有发生则顺序执行try的代码块不会进入到catch块
如果不管是否发生异常都执行某段代码则放入finally块
可以 有多个catch语句，捕获不同的异常（进行不同的业务处理），要求父类异常在后，子类异常在前
可以使用try-finally配合使用，这种做法相当于灭有捕获异常，因此程序会直接崩溃/退出

public class TryCatchDetail02 {
	public static void main(String[] args) {
		//老韩解读
		//1.如果 try 代码块有可能有多个异常
		//2.可以使用多个 catch 分别捕获不同的异常， 相应处理
		//3.要求子类异常写在前面， 父类异常写在后面
		try {
			Person person = new Person();
			//person = null;
			System.out.println(person.getName());//NullPointerException
			int n1 = 10;
			int n2 = 0;
			int res = n1 / n2;//ArithmeticException
		} catch (NullPointerException e) {
			System.out.println("空指针异常=" + e.getMessage());
		} catch (ArithmeticException e) {
			System.out.println("算术异常=" + e.getMessage());
		} catch (Exception e) {
			System.out.println(e.getMessage());
		} finally {
		}
	}
} 

class Person {
	private String name = "jack";
	public String getName() {
		return name;
	}
}

public class TryCatchDetail03 {
	public static void main(String[] args) {
		/*
		可以进行 try-finally 配合使用, 这种用法相当于没有捕获异常，
		因此程序会直接崩掉/退出。 应用场景， 就是执行一段代码， 不管是否发生异常，
		都必须执行某个业务逻辑
		*/
		try{
			int n1 = 10;
			int n2 = 0;
			System.out.println(n1 / n2);
		}finally {
			System.out.println("执行了 finally..");
		} 
			System.out.println("程序继续执行..");
	}
}

2.2 throws 异常处理

throws异常处理
如果一个方法中的语句执行时可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示的声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理
在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以时它的父类

public static void readFile(String file) throws FileNotFoundException
{
	//...
	//读取文件时可能产生FileNotFoundException类型的异常
	FileInputStream fis = new FileInputStream("d://aa.txt");
	//...
}

throws异常处理使用细则
对于编译异常，程序中必须处理，比如try-catch或者throws
对于运行时异常，程序中如果没有处理，默认就是throws的方式处理
子类重写父类的方法时，对抛出异常的规定：子类重写的方法，所抛出的异常类型要么和父类抛出的异常一样，要么为父类抛出的异常的类型的子类型
在throws过程中，如果有方法try-catch，就相当于处理异常，就可以不必thrwos

package com.hspedu.throws_;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ThrowsDetail {
	public static void main(String[] args) throws Exception{//默认抛出给jvm
		f2();
	} 
	public static void f2() /*throws ArithmeticException*/ 
	{
		//1.对于编译异常， 程序中必须处理， 比如 try-catch 或者 throws
		//2.对于运行时异常， 程序中如果没有处理， 默认就是 throws 的方式处理
		int n1 = 10;
		int n2 = 0;
		double res = n1 / n2;
	} 
	public static void f1() throws FileNotFoundException {
		//这里大家思考问题 调用 f3() 报错
		//老韩解读
		//1. 因为 f3() 方法抛出的是一个编译异常
		//2. 即这时， 就要 f1() 必须处理这个编译异常
		//3. 在 f1() 中， 要么 try-catch-finally ,或者继续 throws 这个编译异常
		f3(); // 抛出异常
	} 
	public static void f3() throws FileNotFoundException {
		FileInputStream fis = new FileInputStream("d://aa.txt");
	} 
	public static void f4() {
		//老韩解读:
		//1. 在 f4()中调用方法 f5() 是 OK
		//2. 原因是 f5() 抛出的是运行异常
		//3. 而 java 中， 并不要求程序员显示处理,因为有默认处理机制
		f5();
	} 
	public static void f5() throws ArithmeticException {
	}
}

class Father { //父类
	public void method() throws RuntimeException 
	{
	
	}
} 

class Son extends Father {//子类
	//3. 子类重写父类的方法时， 对抛出异常的规定:子类重写的方法，
	// 所抛出的异常类型要么和父类抛出的异常一致， 要么为父类抛出的异常类型的子类型
	//4. 在 throws 过程中， 如果有方法 try-catch , 就相当于处理异常， 就可以不必 throws
	@Override
	public void method() throws ArithmeticException {
	}
}

2.3 自定义异常处理

当程序中出现了某些”错误“，但该错误信息并没有在Throwable子类中描述处理，这个时候可以自己设计异常类，用于描述该错误信息。

自定义异常的步骤
1)定义类 ：自定义异常类名 继承Exception或者RuntimeException
2)如果继承Exception属于编译异常
3)如果继承RuntimeException属于运行异常

public class CustomException {

	public static void main(String[] args) /*throws AgeException*/ {
		int age = 180;
		//要求范围在 18 – 120 之间， 否则抛出一个自定义异常
		if(!(age >= 18 && age <= 120)) {
		//这里我们可以通过构造器， 设置信息
			throw new AgeException("年龄需要在 18~120 之间");
		} 
			System.out.println("你的年龄范围正确.");
	}
	
} 
	
//自定义一个异常
//老韩解读
//1. 一般情况下， 我们自定义异常是继承 RuntimeException
//2. 即把自定义异常做成 运行时异常， 好处时， 我们可以使用默认的处理机制
//3. 即比较方便
class AgeException extends RuntimeException {
	public AgeException(String message) {//构造器
		super(message);
	}
}

2.4 throw 和 throws 的区别

---

总结

异常处理可以增强程序的健壮性。