异常处理 ？处理（try-catch) ：甩锅（throws）_ java异常(Exception)处理
目录点击跳转
- 本章概要
- java异常处理入门
- 异常介绍
-
- 异常分类
- 异常体系图
- 运行时异常
- 编译异常
- 异常课堂练习
- 异常处理
- ` try-catch `异常处理
-
- `try-catch`异常处理小测试
- `throws`异常处理
- 自定义异常
- `throw`和`throws`的区别
本章概要
本章主要和大家一起学习java异常类的处理机制，深入学习java异常类。
掌握异常处理机制，及背后的逻辑。
1.了解异常体系，学习常见的异常类
2.知道如何处理异常，掌握try-catch 或者 throws的使用和区别
3.能够读懂异常代码，知道何处可能会有异常出现
java异常处理入门
二话不说，先看代码！
//异常处理入门
public class Exception1 {
public static void main(String[] args) {
int m = 10;
int n = 0;
System.out.println(m/n);//分母不能为0 算数异常
System.out.println("程序继续....");//异常导致程序奔溃并未执行该语句
}
}
可以看到当一个代码某个语句出现异常，如果我们不做任何处理，java程序就会奔溃，导致程序中断，后面的语句无法执行！
那如果我们是一个团队在写一个项目，我们有成千上万行代码，如果应因为某一行语句出现异常，而导致整个项目奔溃，显然不合理！
我们可以采取解决方案将异常处理
捕捉异常
对异常进行捕获，保证程序可以继续运行。
用try-catch语句进行捕捉异常，大致细节我们后面讲到，我们先看下面代码：
//try-catch对异常捕捉
public class Exception1 {
public static void main(String[] args) {
int m = 10;
int n = 0;
try {
System.out.println(m/n);//分母不能为0 算数异常
} catch (Exception e) { //捕捉异常
System.out.println(e.getMessage());//打印异常信息
}
System.out.println("程序继续...."); //处理完异常继续执行该语句
}
}
我们可以看到捕捉处理异常后程序可以正常执行！
我们再来学习一下try-catch语句在IDEA下的快捷键吧！
1.首先我们选中将会报异常的语句
2.快捷键Ctrl+Alt+T
3.选中要进行的操作
异常介绍
异常分类
java异常分为两大类:
Error(错误)
java虚拟机无法解决的重大问题，JVM系统内部错误，资源耗尽等严重情况。如：栈溢出StackOverflowError,内存不足out of memory(OOM)。Error是严重错误，会导致程序奔溃！就好比人得了绝症，没得救！Exception
由编程错误或其他外界因素导致的一般性问题，可以通过针对性的代码来处理。例如：空指针访问，文件是否存在，数据库连接等等。
Exception又分为两种：
1.受查（编译）异常:在编译器期间，编译器便能够查出的错误！
2.非受查（运行）异常RuntimeException：在运行期间才会报错！
异常体系图
只是举例了几种常见的异常！
大家可以下去自行查看
异常体系图十分方便体现了继承和实现的关系!
虚线是实现接口，实线是继承父类!
IEDA查看类的关系图步骤：
1.找到一个类选中
2.鼠标右击
3.选择
4.然后再选择该类，鼠标右击查看，选择你要展现父类或者子类！
异常体系图的小结
基本概念
java语言中，将程序执行中出现的不正常情况称为“异常”（开发中语法错误和逻辑错误不是异常）
运行时异常
常见的运行时异常包括
NullPointerException空指针异常ArithmeticException数学运算异常ArrayIndexOutOfBoundsException数组下标越界异常ClassCastException类型转换异常NumberFormatException数字格式不正确异常
常见运行时异常举例
NullPointerException空指针异常
//空指针异常
public class NullPointerException_ {
public static void main(String[] args) {
String str = null;
System.out.println(str.length());//NullPointException
}
}
-ArithmeticException 数学运算异常
//数学运算异常
public class ArithmeticException_ {
public static void main(String[] args) {
int m = 10;
int n = 0;
System.out.println(m/n);//分母不能为0 算数异常
}
}
ArrayIndexOutOfBoundsException数组越界异常
//数组下标越界异常
public class ArrayIndexOutOfBoundsException_ {
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr[4]); //arr下标[0,2]
}
}
ClassCastException类型转换异常
//类型转换异常
public class ClassCastException_ {
public static void main(String[] args) {
String string = "java";
Object ob = string; //上转型对象
Integer integer = (Integer)ob; //类型转换异常
}
}
-NumberFormatException 数字格式不正确异常
//数字格式不正确异常
public class NumberFormatException_ {
public static void main(String[] args) {
int a = Integer.parseInt("1aba");//将字符串转换成整型
//数字格式不正确异常
}
}
编译异常
编译异常就是在编译期间就要处理的异常，也叫受查异常，就是说编译器在编译期间会进行检查，不处理该异常，就无法通过编译。
编译异常必须处理！
常见编译异常：
1.SQLException //操作数据库时，查询表可能发生异常
2.IOException //操作文件时，发生的异常
3.FileNotFoundException //当操作一个不存在文件时，发生的异常
4.EOFException//操作文件，文件到末尾，发生的异常
5.IllegalArgumentException//参数异常
编译异常举例
因为bug郭还没有学习到数据库和文件操作。我们就举一个案例来了解一下编译异常！
//操作文件，发生的编译异常
public class IOException_ {
public static void main(String[] args) {
File file = new File("D:\\a.txt");
file.createNewFile();//异常
}
}
可以看到编译异常，如果我们不进行处理，代码就无法编译通过！
//try-catch处理异常
public static void main(String[] args) {
File file = new File("D:\\a.txt");
//try-catch处理异常 快捷键：Ctrl+Alt+T
try {
file.createNewFile();//异常
} catch (IOException e) {
e.printStackTrace();
} finally {
}
}
异常课堂练习
我们了解了异常，哪来看看下面代码是否会发生异常吧！
//题目一
public static void main(String[] args) {
String[] strings = new String[]{"java","bug","2022"};
System.out.println(strings[3]);
}
结果：
ArrayIndexOutOfBoundsException数组下标越界异常
//题目二
public static void main(String[] args) {
String string = "java";
Object ob = string;
Integer integer = (Integer)ob;
}
ClassCastException类型转换异常
//题目三
class Cat{
public String name;
Cat(String name){
this.name = name;
}
}
public class test_1 {
public static void main(String[] args) {
Cat cat= new Cat("豆花");
cat = null;
System.out.println(cat.name);
}
}
-NullPointerException空指针异常
//题目四
public class Test_1 {
public static void main(String[] args) {
int[] array = new int[]{1,3,3,4,5,6};
array = null;
for (int x:
array) {
System.out.print(x+" ");
}
}
}
异常处理
基本介绍
异常处理就是，当异常发生时，对异常处理的方式！
异常处理方式
try-catch-finally程序员在代码中捕获发生的异常，自行处理throws将发生的异常交给调用者（方法）来处理，最顶级的处理者就是JVM
try-catch-finally处理方式介绍
//`try-catch-finally异常处理机制介绍
class Exception_1{
public static void exception_(){
//异常处理在方法中
try {//可能出现异常的代码用try包裹
String str = "try-catch-finally";
System.out.println("异常语句前面的代码会执行");
str = null; int len = str.length();//出现异常代码
//上方语句出现异常后,后面的语句将不会执行,直接到catch
System.out.println("异常的代码后面的代码不执行");
} catch (Exception e) {
//如果异常是catch里中的异常类型或者子类
//将会捕捉到异常对象e,我们可以通过异常对象得到异常信息...
System.out.println("catch捕捉到了异常!");
} finally {
//不管代码是否被捕捉到异常,finally语句都会被执行
// finally代码块中的语句一定会执行
}
System.out.println("程序继续...");
}
}
throws处理方式介绍
//throws机制处理异常方式
public class Test_3 {
//抛出异常通常定义在 方法头部()后面 throws + 异常类型
public static void main(String[] args) throws NumberFormatException{
f1();
}
public static void f1()throws NumberFormatException{
f2();//两种选择，处理或者抛出
}
public static void f2()throws NumberFormatException{
f3();//两种选择，处理或者抛出
}
public static void f3()throws NumberFormatException{
f4();//两种选择，处理或者抛出
}
public static void f4()throws NumberFormatException{
throw new NumberFormatException();
//出现异常，f4可选择try-catch-finally捕捉异常
// 或者throws抛出给调用者
}
}
JVM处理后，打印异常信息，退出程序
throws处理异常方式就是将异常抛出给调用者（方法）,每个接收到异常的调用者（方法）都有两种处理异常的方式：1.向上抛给他的调用者 2.try-catch-finally捕获异常如果一直向上抛给调用者,如果最后的调用者main方法也继续抛出，那么最终会由JVM处理该异常，并输出异常信息，最后程序中断，退出程序。
还有我们的java程序如果我们程序员不处理异常，默认throws所以也就解释了为啥出现异常，程序便会中断，因为默认是throws机制处理异常，然后抛给JVM处理异常，打印异常信息，直接退出程序。
try-catch异常处理
我们刚刚介绍了try-catch处理异常的机制，我们现在来深入学习一下try-catch异常处理的一些细节！！
可以看到java提供try和catch块来处理异常，try代码块中包含可能出错的代码，catch捕捉try块中出现的异常，如果捕捉到该异常，就在catch代码块中进行异常处理，打印异常等等，而try-cath-finally组合处理异常，finally代码块中不管是否捕捉到异常都将最后执行，并且一定会被执行！！也可以没有finally代码块，try-catch组合处理异常！
注意事项
我们通过下面的代码案例来学习一些try-catch异常处理的细节吧！
//案例一
public class TryCatchDetail {
public static void main(String[] args) {
//ctrl + atl + t 快捷键 try-catch-finally语句！
//1. 如果异常发生了，则异常发生后面的代码不会执行，直接进入到 catch 块
//2. 如果异常没有发生，则顺序执行 try 的代码块，不会进入到 catch
//3. 如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)则使用如下代码- finally
try {
String str = "bug郭";
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("程序继续...");
}
}
//案例二
class Person {
private String name = "jack";
public String getName() {
return name;
}
}
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 {
}
}
}
//案例三
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("程序继续执行..");
}
}
总结：
-
try-catch-finally异常处理可以有多种组合，try-catch（捕捉异常，不善后，程序继续运行，），try-finally（不捕捉异常，finally代码块一定会执行） -
可以有多个
catch语句，并且需要遵循异常子类在前原则，否者在前捕获到了异常，后面子类就会无法通过编译报错！ -
如果有
fianlly代码块，那里面的语句一定为执行，不管是否捕捉了异常！！！
try-catch异常处理小测试
既然已经学到这里了，那我们来巩固测试一下！读代码写结果吧！
//测试一
public class Test_2 {
public static int method(){
try {
String[] names = new String[3];//String[]数组
if(names[1].equals("bug郭")){
System.out.println(names[1]);
}else {
names[3] = "java";
}
return 1;
}catch (ArrayIndexOutOfBoundsException e) {
return 2;
} catch (NullPointerException e) {
return 3;
} finally {
return 4;
}
}
public static void main(String[] args) {
System.out.println(method());//执行结果？
}
}
//测试一题解
public class Test_2 {
public static int method(){
try {
String[] names = new String[3];//String[]数组
if(names[1].equals("bug郭")){//null空指针异常names数组里的元素为null
System.out.println(names[1]);
}else {
names[3] = "java";
}
return 1;
}catch (ArrayIndexOutOfBoundsException e) {
return 2;
} catch (NullPointerException e) {
return 3;//捕捉到异常 先将3保存
} finally {
return 4; //一定要执行 所以最后return 4!!!
}
}
public static void main(String[] args) {
System.out.println(method());//执行结果:4
}
}
//测试二
public class Test_3 {
public static int method(){
int i =1;
try {
i++;
String[] names = new String[3];//String[]数组
if(names[1].equals("bug郭")){//空指针
System.out.println(names[1]);
}else {
names[3] = "java";
}
return 1;
}catch (ArrayIndexOutOfBoundsException e) {
return 2;
} catch (NullPointerException e) {
return ++i;
} finally {
return ++i;
}
}
public static void main(String[] args) {
System.out.println(method());//执行结果？
}
}
//测试二题解
public class Test_3 {
public static int method(){
int i =1;
try {
i++; //i=2！
String[] names = new String[3];//String[]数组
if(names[1].equals("bug郭")){//空指针异常直接执行catch语句！
System.out.println(names[1]);
}else {
names[3] = "java";
}
return 1;
}catch (ArrayIndexOutOfBoundsException e) {
return 2;
} catch (NullPointerException e) {
return ++i; //i = 3 并且保存了将要返回值为3
} finally {
return ++i; //i = 4 一定要执行,将 i = 4返回！
}
}
public static void main(String[] args) {
System.out.println(method());//执行结果：4！！！
}
}
//测试三
public class Test_4 {
public static int method(){
int i =1;
try {
i++;
String[] names = new String[3];
if(names[1].equals("bug郭")){
System.out.println(names[1]);
}else {
names[3] = "java";
}
return 1;
}catch (ArrayIndexOutOfBoundsException e) {
return 2;
} catch (NullPointerException e) {
return ++i;
} finally {
++i;
System.out.println("i="+i);
}
}
public static void main(String[] args) {
System.out.println(method());//执行结果？
}
}
//测试三题解
public class Test_4 {
public static int method(){
int i =1;
try {
i++;//i=2
String[] names = new String[3];
if(names[1].equals("bug郭")){//空指针异常
System.out.println(names[1]);
}else {
names[3] = "java";
}
return 1;
}catch (ArrayIndexOutOfBoundsException e) {
return 2;
} catch (NullPointerException e) {
return ++i; //i = 3 并且用临时变量保存了该返回值3！
} finally {
++i; // i = 4
System.out.println("i="+i); //打印 i= 4
}
} //最终函数返回:3
public static void main(String[] args) {
System.out.println(method());//执行结果:i= 4 3
}
}
throws异常处理
基本介绍
throws异常处理是java处理异常的另一种方式，也是JVM的默认处理机制！
刚刚我们也已经介绍过了！
简单说就是：如果一个方法中的某处代码出现了异常，那么该方法就要进行异常异常处理！try-catch或者throws（如果不对异常进行处理那么默认也是throws）而throws处理机制就是将异常（向上一级抛）抛给方法的调用者，如果调用者都不进行异常处理，那么最终会有JVM处理，程序中断！
//throws异常处理细节！
public class ThrowsDetail {
public static void main(String[] args) {
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 {
}
}
自定义异常
基本概念
当程序中出现某些“错误”，但该错误信息并没有在Throwable子类中描述处理，这个时候我们可以自己设计异常类，用于描述该错误信息。
自定义异常步骤
1.定义类：自定义异常类名（设计者自己编写）继承Exception或RuntimeException
2.如果继承Exception,属于编译异常
3.如果继承RuntimeException,属于运行异常（一般来说，继承RuntimeException）
实例
客户需求：当我们接收Person对象年龄时，要求范围在18-120之间，否者抛出一个自定义异常，并给出提示！
//解决方案
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);
}
}
throw和throws的区别
| 意义 | 位置 | 后面跟的内容 | |
|---|---|---|---|
| throws | 异常处理的一种方式 | 方法声明处 | 异常类型 |
| throw | 手动生成异常对象关键字 | 方法体中 | 异常对象 |
java异常章节学习到这里！如果对大家有所帮助，还望多多支持！如有错误多多指正！内容来自bug郭在B站学习韩顺平的java课程自己整理的笔记！
互关互访互相支持，一起进步！、~