第十章：异常

系列文章目录

---

---

前言

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

---

一、异常

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

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

1.1 常见运行时异常

1.2 常见编译时异常

二、异常处理

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

2.1 try-catch 异常处理

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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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());
	} 
}
1
2
3
4
5
6
7
8
9

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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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("程序继续执行..");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.2 throws 异常处理

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

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 {
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

2.3 自定义异常处理

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

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);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2.4 throw 和 throws 的区别

---

总结

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