Java面向对象笔记 • 【第5章 异常处理】

全部章节   >>>>

---

本章目录

5.1 异常概述

5.1.1 程序中的异常

5.1.2 异常分类

5.1.3 实践练习

5.2 try-catch处理异常

5.2.2 使用finally回收资源

5.2.3 实践练习

5.3 throws与throw

5.3.1 使用throws声明抛出异常

5.3.2 使用throw抛出异常

5.3.3 实践练习

5.4 自定义异常

5.4.1 创建自定义异常

5.4.2 自定义异常应用

5.4.3 实践练习

总结：

---

5.1 异常概述

生活中的异常

程序中的异常

5.1.1 程序中的异常

在Java语言中，异常是指程序在运行期间发生的事件，它是导致程序中断运行的正常指令流。

例如，在算术运算中除数为0、数组越界、空指针异常等，这些事件的发生都会阻止程序的正常运行。

示例：演示除法运算

public class MathCalc {
	public static  int division(int dividend,int divisor){
		return  dividend/divisor;
	}
	public static void main(String[] args) {
		System.out.println(MathCalc.division(100, 0));
	}
}

 

5.1.2 异常分类

1、Throwable类

位于异常类层次结构的顶端，它是Java中所有错误和异常的父类。

2、Error类

通常指与虚拟机相关的问题，如系统崩溃、虚拟机错误、动态链接失败等。

这种错误无法恢复或不可能捕获，将导致应用程序中断。通常程序无法处理这些错误。

3、Exeception类

该类型的异常在程序中发生后可以进行捕获处理，处理后程序正常运行，从而保证程序的稳定性及健壮性。

Java程序开发中的异常处理，主要是针对Exception类及其子类进行的。

示例：演示数组下标越界异常

public class RunException {
	 public static void showRuntimeException(){
		 int[] data=new int[2];
		 System.out.println(data[2]);
	 }
	 public static void main(String[] args) {
	          RunException.showRuntimeException();
	 }
}

分析：

• 上述程序的数组长度为2，数组中元素的索引范围为0～1，当程序取索引值1时，超出了索引的取值范围，从而产生了数组下标越界。
• 由于没有进行异常处理，程序立即终止。
• 该异常属于运行时异常，其特点是：程序编译时可通过，但运行时却发生异常。

常见运行时异常RuntimeException

异常类名称	说明
ArithmeticException	算术异常
ArrayIndexOutOfBoundsException	数组索引为负或大于等于数组大小异常
ClassCastException	对象转换异常
IllegalArgumentException	调用方法时传入非法参赛异常
IndexOutOfBoundsException	数组索引越界异常
NegativeArraySizeException	数组长度为负值异常
NullPointerException	空指针指向异常
NumberFormatException	数字格式异常
StringIndexOutOfBoundsException	字符串索引越界异常
UnsupportedOperationException	操作错误异常

5.1.3 实践练习

 

5.2 try-catch处理异常

Java异常处理的作用和运行机制：

Java的异常处理机制可以保障程序具有良好的容错性，使程序健壮性更高。

当程序运行出现意外情形时，系统会自动生成一个Exception类型的子类对象来通知程序，从而实现业务功能的代码与错误处理代码分离，使程序具有更好的可读性。

Java的异常处理机制提供了两种方式来处理异常，一种是使用“try-catch”语句处理异常，另一种是在方法声明时使用throws关键字将异常抛出。

语法：

try{
	//可能出现异常的语句
}catch(异常类型1 异常对象1){
          //异常处理代码
}

示例：演示try-catch捕获异常

try{
	//创建Scanner对象，用于接收控制台输入的数据
	Scanner input=new Scanner(System.in);
	System.out.println("请输一个整数除数:");
	int num=input.nextInt();
	System.out.println("您输入的数字是:"+num);
}catch(InputMismatchException e){
	System.err.println("输入不匹配异常:程序只能接收整数");
}

注意：

一个try块可以对应多个catch块，构成多重catch语句块，多重catch语句块用于对多个不同的 异常类型进行捕获，但最多只能选中一个执行。

先处理小异常，再处理大异常。即进行异常捕获时不仅应该将Exception类对应的catch块放在最后，而且所有父类异常的catch  块都应该放在子类异常catch块的后面，否则将出现编译错误。

示例：演示多重catch语句块

try{
	Scanner input=new Scanner(System.in);
	System.out.println("请输入被除数:");
	int divisor=input.nextInt();
	System.out.println("请输出除数:");
	int dividend=input.nextInt();
	System.out.println("您输入的两个数的是:"+divisor/dividend);
}catch(InputMismatchException e){
	System.err.println("输入不匹配异常:程序只能接收整数");
}
catch (ArithmeticException e) {
	System.err.println("算数异常:0不能作为被除数");
}catch(Exception e){
	System.err.println("未知异常");
}

注意：catch块范围大的异常放在后面

 

 

5.2.2 使用finally回收资源

语法：

try{
	//可能出现异常的语句
}catch(异常类型1 异常对象1){
          //异常处理代码
} finally{
  //资源回收代码
}

说明：

finally块保证回收在try块中打开的物理资源，如数据库连接、网络连接或磁盘文件等。

无论try语句块中的代码是否出现异常，try语句块对应的任意一个catch语句块是否被执行，甚至在try或catch语句块中执行了return语句，finally块总会被执行。

无论是try语句块还是catch语句块中使用return语句，都要先执行完finally语句块后，再返回当前方法。

try语句不能独立存在，其后至少要有一个catch语句块或finally语句块。

finally语句块不是必须存在的，可以根据需求决定是否添加。

示例：使用try-catch-finally模拟文件操作过程中的异常处理

try{
	//创建Scanner对象，用于接收控制台输入的数据
	Scanner input=new Scanner(System.in);
	System.out.println("请输一个整数除数:");
	int num=input.nextInt();
	System.out.println("您输入的数字是:"+num);
}catch(InputMismatchException e){
	System.err.println("输入不匹配异常:程序只能接收整数");
}

5.2.3 实践练习

 

 

5.3 throws与throw

Java 强烈要求应用程序进行完整的异常处理。

throws用来声明一个方法可能抛出的所有异常信息。通常不用显示地捕获异常，系统将自动将异常抛给上级方法，throws出现在方法的头部。

throw指程序运行中抛出的一个具体的异常Exception，抛出的Exception需要用户来捕获处理。

语法：

[访问控制符]  返回类型  方法名称([参数列表])  throws  异常类1,  异常类2…
{
}

当前方法不知道如何处理当前异常时，可以使用throws关键字声明抛出异常，该异常可由上一级调用者处理。

throws声明只能在方法签名中使用。

throws可以声明抛出多个异常类，多个异常类之间以逗号隔开。

5.3.1 使用throws声明抛出异常

示例：在读取文件方法声明时使用Throws抛出可能异常

public class Read {
	//使用throws抛出程序可能发生的异常类，可由调用该方法处捕获处理
	public static void readFile() throws ClassNotFoundException,FileNotFoundException{
		//将com.java.Read类加载到JVM的内存中
		Class.forName("com.java.Read");
		//创建FileInputStream实例，用于读取文件中的数据
		FileInputStream  fis=new FileInputStream("c://file.txt");
	}
	public static void main(String[] args) {
		try {
			Read.readFile();
		} catch (FileNotFoundException e) {
			e.printStackTrace();//显示堆栈异常信息
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}

如果在main()方法中未使用try-catch捕获readFile()方法抛出的异常，而是在main()中继续将异常抛出，此时该异常交给JVM虚拟机进行处理。

不提倡开发人员在main()中将异常继续向上抛给JVM。

5.3.2 使用throw抛出异常

语法：

throw  异常类对象

在实际的企业项目开发中，系统是否要抛出异常，可能需要根据应用的业务需求来决定，如果程序中的数据处理与指定的业务需求不符，这就是一种异常。

与业务需求不符而产生的异常，必须由开发人员来决定抛出，系统无法抛出这种异常。

如果需要在程序中自行抛出异常，则应该使用throw语句。

throw语句抛出的不是一个异常类，而是一个异常实例，且每次只能抛出一个异常实例。

示例：使用throw抛出异常保证员工年龄合乎企业用人规则

public class UserInfo {
	private String name;
	private int age;
	...
	public void setAge(int age) throws Exception {
		if(age<18 || age>60){
			//使用throw抛出异常
			throw new Exception("员工年龄应该在18岁至60岁之间");
		}
		this.age = age;
	}
	...
	public static void main(String[] args) {
		UserInfo userInfo=new UserInfo();
		userInfo.setName("俞敏红"); //姓名赋值
		try {
			userInfo.setAge(10);  //年龄赋值
		    userInfo.showEmpInfo(); //显示员工信息
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

throws和throw的区别

throws	throw
声明一个方法可能抛出的所有异常类型	抛出一个具体的异常类实例
不用显式地捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法（即方法的调用者）	需要程序员自行捕获相关的异常
throws在方法头声明	throw在方法内部使用

5.3.3 实践练习

5.4 自定义异常

问题1：将员工的工资输入为负数。

问题2：将订单的下单日期输入为超过当期时间。

。。。

5.4.1 创建自定义异常

自定义异常类需要继承自Exception类。

示例：创建自定义异常类

public class AuctionException extends Exception{
	//无参构造方法
	public  AuctionException(){
	}
	public AuctionException(String message){
		//调用父类有参构造器
		super(message);
	}
}

5.4.2 自定义异常应用

1、异常处理的复杂性

异常不能由当前方法处理。

异常由当前方法处理一部分，另一部分交由当前方法的调用者进行处理，此时需要在当前方法中抛出异常。

2、多个方法相互协作处理异常

示例：使用自定义异常处理拍卖过程中的错误操作（亦可说使用自定义异常处理拍卖过程中的业务逻辑异常）。

public class AuctionTest {
	private double initPrice=30; //起拍价
	public void bid(String bidPrice) throws AuctionException{
		double d=0;
		try {
			//将字符串格式的小数转换为double类型的数据
			d=Double.parseDouble(bidPrice);
		} catch (Exception e) {
			e.printStackTrace();
			//抛出自定义异常
			throw new AuctionException("输入的竞拍价格必须为小数格式");
		}
		if(initPrice>d){
			//如果竞拍价格低于起拍价格，则视为异常，使用throw抛出自定义异常对象
			throw new AuctionException("竞拍价格低于起拍价格，不许竞拍");
		}
		initPrice=d;
	}

public class AuctionTest {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		System.out.println("请输入商品的竞拍价格:");
		AuctionTest  auctionTest=new AuctionTest();
		try {
			auctionTest.bid(input.next());
		} catch (AuctionException e) {
		  //捕获bid()方法抛出的异常，显示异常提示信息
		   System.out.println(e.getMessage());
		}
	}
}

5.4.3 实践练习

总结：

1. Java的异常处理机制可以保障程序具有良好的容错性，使程序健壮性更高。Exception是Java异常的父类。
2. 运行时异常的父类是RuntimeException，它的特点是程序编译时可通过，但运行时却发生异常。常见的运行时异常有：ArithmeticException、ArrayIndexOutOfBoundsException、NullPointerException、ClassCastException、IllegalArgumentException
3. Java的异常处理机制提供了两种方式来处理异常，一种是使用“try-catch”语句处理异常，它将可能发生异常的代码放在try块，异常处理代码放在catch块；另一种是在方法声明时使用throws关键字将异常抛出，抛出的异常由调用者进行处理
4. finally块保证回收在try块中打开的物理资源，如数据库连接、网络连接或磁盘文件等。
5. 在方法中可以使用throw主动抛出一个异常对象。
6. 自定义异常类需要继承自Exception类，定义合适的自定义异常可以解决业务逻辑规则的不正常情况。