文章目录
- 一、异常简介
- 二、异常体系图
- 三、常见的异常
- 3.1 常见的运行时异常
- 3.2 常见的编译异常
- 四、异常处理
- 4.1 异常处理的方式
- 4.2 try-catch异常处理
- 4.2.1 try-catch异常处理基本语法
- 4.2.2 try-catch异常处理的注意细节
- 4.3 throws异常处理
- 4.3.1 throws异常处理基本介绍
- 4.3.2 throws注意事项和使用细节
- 五、自定义异常
- 5.1 自定义异常基本概念
- 5.2 自定义异常的步骤
- 六、throw和throws的对比
- 七、细节
- 7.1 异常分类
- 7.2 try-catch-finally与return的使用逻辑
- 7.2.1 在try和catch中有return，finally中没有return
- 7.2.2 在try和catch中有return，finally中没有return
- 7.2.3 在try和catch中有return，finally中也有return
- 7.2.4 在try中有return，在catch中新抛出异常，finally中有return
- 7.3 对于 `编译时` 与 `运行时异常的` 处理机制
一、异常简介
二、异常体系图
- 根类：
Throwable
三、常见的异常
3.1 常见的运行时异常
3.2 常见的编译异常
四、异常处理
4.1 异常处理的方式
- 方式一：try{…}catch(){…}finally{…}
try{
代码/可能有异常
}catch(Exception e){
// 捕获到异常
// 1. 当异常发生时
// 2. 系统将异常封装成 Exception 对象 e，传递给catch
// 3. 得到异常对象后，程序员自己处理
}finally{
// 1. 不管try代码块是否有异常发生，始终要执行finally
// 2. 所以，通常将释放资源的代码，放在finally中
}
- 方式二：
throws
4.2 try-catch异常处理
4.2.1 try-catch异常处理基本语法
4.2.2 try-catch异常处理的注意细节
package com.throwable_;
/**
* @author Gao YongHao
* @version 1.0
*/
public class Exception02 {
public static void main(String[] args) {
// 1. 如果try代码块有可能有多个异常
// 2. 可以使用多个catch分别捕获不同的异常，相应处理
// 3. 要求子类异常在前面，父类异常写在后面
try {
Person p = new Person();
p = null;
System.out.println(p.name);
int n1 = 10;
int n2 = 0;
System.out.println(n1 / n2);
} catch (ArithmeticException e) {
System.out.println("算数异常：" + e.getMessage());
} catch (NullPointerException e) {
System.out.println("空指针异常" + e.getMessage());
} catch (Exception e) {
System.out.println(e.getMessage());
} finally {
}
System.out.println("程序继续执行");
}
}
class Person {
String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
4.3 throws异常处理
4.3.1 throws异常处理基本介绍
public class Throws01{
public void f2 throws FileNotFoundException,NullPointerException(){
// 创建了一个文件流对象
// 解读：
// 1. 这里的异常是一个 FileNotFoundException 编译异常
// 2. 使用前面讲过的 try-catch-finally
// 3. 使用throws，抛出异常，让调用f2方法的调用者（方法）进行处理
// 4. throws 后面的异常类型可以是方法中产生的异常类型，也可以是它的父类
// 5. throws 关键字后也可以是 异常列表，即可以抛出多个异常
FileInputStream fis = new FileInputStream('....')
}
}
4.3.2 throws注意事项和使用细节
五、自定义异常
5.1 自定义异常基本概念
5.2 自定义异常的步骤
public class CustomException{
public static void main(String[] args){
int age = 180;
// 要求范围在: 18 - 120 之间，否则抛出一个自定义异常
if(!(age >= 18 && age <= 180)){
throw new AgeException("年龄需要在 18~120 之间");
}
System.out.println("你的年龄范围正确");
}
}
// 自定义一个异常
// 解读
// 1. 一般情况下，我们自定义异常是继承 RuntimeException
// 2. 即把自定义异常做成 运行时异常，好处是，我们可以使用默认的处理机制
class AgeException extends RuntimeException{
public AgeException(String message){
super("message");
}
}
六、throw和throws的对比
七、细节
7.1 异常分类
- 异常
- 错误
- Exception
- 运行时异常
- 编译时异常
7.2 try-catch-finally与return的使用逻辑
https://www.cnblogs.com/sunshineweb/p/7656463.html try catch finally 中包含return的几种情况，及返回结果
7.2.1 在try和catch中有return，finally中没有return
public class Test {
public static int num=1;
public static void main(String[] args) throws ParseException {
int result;
result = num();
System.out.println(result);
}
private static int num() {
try{
int b=4/0;
return num = num+2;
}catch(Exception e){
return num = num+3;
}finally {
System.out.println("不管你怎么样，我都是要执行");
}
}
}
/*
输出内容为：
不管你怎么样，我都是要执行
4
*/
// 原因，int b=4/0;发生了异常，直接进入catch的代码块中执行了return num = num+3;此时把返回的结果4。如果没有异常的话会执行try中的return，catch中的代码不会执行，但是无论怎样，finally中的代码都会执行。
7.2.2 在try和catch中有return，finally中没有return
要返回的数据是基本数据类型还是引用数据类型，对结果也有不同的影响
- 返回的数据为
基本数据类型，则finally中对要返回数据操作无影响
public class Test {
public static int num=1;
public static void main(String[] args){
int result;
result = num();
System.out.println(result);//结果不受finally影响，输出4
System.out.println(num);//5
}
private static int num() {
try{
int b=4/0;
return num = num+2;
}catch(Exception e){
return num = num+3;
}finally {
++num;
}
}
}
// result的值为4的原因是，当执行到catch中的 return num = num+3;时，已经把要返回的num的值存到了其他局部变量中，在执行完finally中的++num;后，是从其他局部变量中获取的返回值，而不是直接返回num的值
- 返回的数据为
引用数据类型，finally中如果改变了返回对象的属性则影响结果，如果改变的是对象的引用则和基本数据类型一样不改变结果
public class Test {
public static void main(String[] args) {
People bride;
bride = marry();
System.out.println(bride.getState());//结果受finally影响，输出dead
}
private static People marry() {
People people=new People();
people.setState("happy");;
try{
int b=4/0;
return people;
}catch(Exception e){
return people;
}finally {
people.setState("dead");
}
}
}
// bride.getState()的结果为dead的原因是，当执行到catch中的return people;时，把要返回people的内存地址存储起来，但是finally中对该内存地址对象的属性进行了更改，bride = marry(); 获取的内存地址对应的对象是更改属性后的people，所以属性值改变了。
7.2.3 在try和catch中有return，finally中也有return
- try或catch中
return后面的代码会执行，但最终返回的结果为finally中return的值，需要注意的是try或catch中return后面的代码会执行，只是存起来了，并没有返回，让finally捷足先登先返回了
public class Test {
public static int num=1;
public static void main(String[] args) throws ParseException {
int result;
result = num();
System.out.println(result);//输出结果为1003
System.out.println(num);//输出结果为1001
}
private static int num() {
try{
int b=4/0;
return num = num+1000;
}catch(Exception e){
return num = num+1000;
}finally {
return num+2;
}
}
}
7.2.4 在try中有return，在catch中新抛出异常，finally中有return
- 如果catch块中捕获了异常, 并且在catch块中将该异常throw给上级调用者进行处理, 但finally中有return, 那么catch块中的throw就失效了, 上级方法调用者是捕获不到异常
public class Test {
public static void main(String[] args) throws Exception {
String result="";
try {
result = num();
} catch (Exception e) {
System.out.println("青天大老爷在此");
}
System.out.println(result);
}
public static String num() throws Exception {
try{
int b=4/0;
return "总是异常，反正我又不会执行";
}catch(Exception e){
throw new Exception();
}finally {
return "用金钱蒙蔽你的双眼";
}
}
}
/*
用金钱蒙蔽你的双眼
如果把finally里的return注释掉就会输出：
青天大老爷在此
*/
7.3 对于 编译时 与 运行时异常的 处理机制
- 注意：对于
编译时异常，必须由编写者手动处理；而对于运行时异常默认被自动throws抛出，由上一级调用者(方法)处理
