Java中的异常

最新推荐文章于 2024-06-16 09:46:44 发布

沐夏

最新推荐文章于 2024-06-16 09:46:44 发布

阅读量985

点赞数 24

文章标签： java

本文链接：https://blog.csdn.net/2302_76764006/article/details/136262398

版权

一、异常的概念

异常是指在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序

程序运行--->异常--->程序中断运行

二、异常处理

Java编程语言使用异常处理机制为程序提供了错误处理的能力

程序中预先设置好对付异常的处理方法--->程序运行--->异常--->对异常进行处理--->处理完毕，程序继续运行

三、异常处理方法

Java的异常处理是通过5个关键字来实现的：try、catch、 finally、throw、throws

	捕获异常	声明异常	抛出异常
try--->	执行可能产生异常的代码	throws	throw
catch--->	捕获异常	声明方法可能要抛出的各种异常	手动抛出异常
finally--->	无论是否发生异常，代码总能执行

四、try-catch

使用try-catch块捕获异常，分为三种情况：

1、正常

public void method() {
try {
// 代码段(此处不会产生异常)
} catch (异常类型 e) {
// 对异常进行处理的代码段
}
// 代码段
}

2、出现异常

public void method() {
try {
// 代码段 1
// 产生异常的代码段 2
// 代码段 3
} catch (异常类型 e) {
// 对异常进行处理的代码段4
}
// 代码段5
}

异常是一种特殊的对象，类型为java.lang.Exception或其子类

try---发生异常--->产生异常对象--->异常类型匹配---进入catch块--->catch---程序继续执行--->try-catch后的代码段

3、异常类型不匹配

public void method() {
try {
// 代码段 1
// 产生异常的代码段 2
// 代码段 3
} catch (异常类型 e) {
// 对异常进行处理的代码段4
}
// 代码段5
}

try---发生异常--->产生异常对象--->异常类型不匹配--->程序中断运行

说明：

1）在catch块中处理了异常

加入用户自定义处理信息

System.err.println("出现错误：被除数和除数必须是整数"); // 输出结果是红色字体

2）调用方法输出异常信息

catch(Exception e) {
e.printStackTrace();
}
// 当try语句中出现异常时，会执行catch中的语句，java运行时系统会自动将catch括号中的Exception e初始化，也就是实例化Exception类型的对象。e是此对象引用名称，然后e（引用）会自动调用Exception类中指定的方法，也就出现了e.printStackTrace();
// printStackTrace()方法的意思是：在命令行打印异常信息在程序中出错的位置及原因

3）异常对象常用方法

方法	说明
void printStackTrace()	输出异常的堆栈信息
String getMessage()	返回异常信息描述字符串，是printStackTrace()输出信息的一部分

五、常见的异常类型

异常类型	说明
Exception	异常层次结构的父类
ArithmeticException	算术错误情形，如以零作被除数
ArrayIndexOutOfBoundsException	数组下标越界
NullPointerException	尝试访问 null 对象成员
ClassNotFoundException	不能加载所需的类
IllegalArgumentException	方法接收到非法参数
ClassCastException	对象强制类型转换出错
NumberFormatException	数字格式转换异常，如把"abc"转换成数字

package javaobjectdemo0123.demo01;

public class Demo01 {

public static void main(String[] args) {

try {
int a = 5;
int b = 0;
int result = a / b;
System.out.println(result);
} catch (RuntimeException e) {
System.out.println("程序以零作被除数"); // 程序以零作被除数
}

try {
int[] nums = new int[3];
System.out.println(nums[3]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("程序数组下标越界"); // 程序数组下标越界
}

try {
String str = null;
System.out.println(str.length());
} catch (NullPointerException e) {
System.out.println("程序发生空指针异常"); // 程序发生空指针异常
}

try {
// 尝试加载类的代码
// static Class<?> forName(String className) 返回与带有给定字符串名的类或接口相关联的 Class 对象
Class.forName("com.example.MyClass");
} catch (ClassNotFoundException e) {
// 处理ClassNotFoundException异常的代码
System.out.println("程序不能加载所需的类"); // 程序不能加载所需的类
}

System.out.println("------ ------ ------")

public class Demo02 {

public void doSomething(int value) {
try {
if (value < 0 || value > 100) {
throw new IllegalArgumentException("参数value的取值范围必须在[0, 100]之间");
}
// 其他业务逻辑
} catch (IllegalArgumentException e) {
// 异常处理代码
System.out.println("程序调用方法传参错误");
}
}

}

Demo02 demo02 = new Demo02();
demo02.doSomething(101); // 程序调用方法传参错误

try {
String numString = "abc";
// static int parseInt(String s)将字符串参数作为有符号的十进制整数进行解析
System.out.println(Integer.parseInt(numString));
} catch (NumberFormatException e) {
System.out.println("程序数字格式转换异常"); // 程序数字格式转换异常
}

/*
* 在实际开发中，可能会抛出很多种不同类型的运行时异常，我们可以将它们的父类设为RuntimeException，这样就可以在catch块中捕获并处理这些异常
* */
}
}

package javaobjectdemo0123.demo02;

public class Pet {

public String name;

public Pet() {
}

public Pet(String name) {
this.name = name;
}

public void info() {
System.out.println("我的名字是：" + this.name);
}

}

package javaobjectdemo0123.demo02;

public class Dog extends Pet{

// 子类中特有的属性
public String strain; // 品种

public Dog() {
}

public Dog(String name, String strain) {
super(name);
this.strain = strain;
}

@Override
public void info() {
super.info();
System.out.println("我的品种是：" + strain);
}

// 子类中特有的方法
public void shout() {
System.out.println("拆家旺旺");
}

}

package javaobjectdemo0123.demo02;

public class Cat extends Pet{

// 定义子类中特有的属性
public String color; // 颜色

public Cat() {
}

public Cat(String name, String color) {
super(name);
this.color = color;
}
}

package javaobjectdemo0123.demo02;

public class Test {

public static void main(String[] args) {

// 向上转型
Pet pet1 = new Dog("壮实","萨摩耶");
pet1.info();
System.out.println("------");
// 向下转型
Dog dog1 = (Dog) pet1;
dog1.shout();

System.out.println("------ ------ ------");

Pet pet2 = new Cat("蓝莓","蓝灰色");
pet2.info();
System.out.println("------");
try {
// 向下转型报错
Dog dog2 = (Dog) pet2; // pet2向上转型类型为Cat类
} catch (ClassCastException e) {
System.out.println("程序强制转换类型错误"); // 程序强制转换类型错误
}

}
}

六、try-catch-finally

1、在try-catch块后加入finally块

1）是否发生异常都执行

2）不执行的唯一情况

System.exit(1);

try块---有异常--->catch块(System.exit(1))--->finally块

try块---无异常，中断程序，退出Java虚拟机--->finally块

2、存在return的try-catch-finally块

public void method(){
try {
// 代码段1
// 产生异常的代码段2
} catch (异常类型 ex) {
// 对异常进行处理的代码段3
return;
}finally{
// 代码段4
}
}

try---发生异常--->产生异常对象--->异常类型匹配---进入catch块--->catch(return)--->执行finally--->执行return退出方法

七、多重catch块

引发多种类型的异常

1）排列catch语句的顺序：先子类后父类

2）发生异常时按顺序逐个匹配

3）只执行第一个与异常类型匹配的catch语句

八、小结

1、try-catch-finally结构中try语句块是必须的，catch、finally语句块均可选，但两者至少出现之一

2、try-catch块中存在return语句，是否还执行finally块？如果执行，说出执行顺序

3、try-catch- finally块中， finally块唯一不执行的情况是什么？

存在结束虚拟机语句

九、声明异常

如果在一个方法体中抛出了异常，如何通知调用者？

throws声明某个方法可能抛出的各种异常，多个异常用逗号隔开

1）方式1：调用者处理异常

2）方式2：调用者继续声明异常

main()方法声明的异常由Java虚拟机处理

十、抛出异常

除了系统自动抛出异常外，有些问题需要程序员自行抛出异常

1）使用throw抛出异常

2）throw与throws

throw	throws
生成并抛出异常	声明方法内抛出了异常
位于方法体内部，可作为单独语句使用	必须跟在方法参数列表后面，不能单独使用
抛出一个异常对象，且只能是一个	声明抛出异常类型，可以跟多个异常

/*
在 Java 中，当前执行的语句必属于某个方法。Java 解释器调用 main 方法开始执行一个程序。每个方法都必须声明它可能抛出的必检异常的类型。这称为声明异常只对编译时异常进行声明，告知方法的调用者有异常。为了在方法中声明一个异常，就要在方法头中使用关键字 throws
*/
public void myMethodO throws IOException
/*
关键字 throws 表明 myMethod 方法可齙会抛出异常 IOException。如果方法可能会抛出多个异常，就可以在关键字 throws 后添加一个用逗号分隔的异常列表
*/
public void myMethodO throws Exceptionl, Exception2,… ，ExceptionN
// 注意：如果方法没有在父类中声明异常，那么就不能在子类中对其进行继承来声明异常

package com.learn.demo02;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

public class Demo01 {

// throws是声明异常，必须写在方法的参数列表后，可以写多个异常对象，多个异常对象之间使用逗号隔开
public static void main(String[] args) throws FileNotFoundException {

// 调用一个可成产生异常的方法,调用者使用try-catch来处理可能产生的异常
// try {
// InputStream inputStream = new FileInputStream("F:/a.txt");
// } catch (FileNotFoundException e) {
// throw是抛出异常，写在方法体内部，一次只能抛出一个异常，可以单独写语句
// throw new RuntimeException(e);
// }

// 调用一个可能产生异常的方法，调用者不处理，将异常继续向上声明，-
InputStream inputStream = new FileInputStream("F:/a.txt");
}
}