第八章异常处理

安于时光荏苒

已于 2022-06-01 10:59:56 修改

阅读量277

点赞数

文章标签： java

于 2022-04-20 22:23:55 首次发布

本文链接：https://blog.csdn.net/hmaxbetter/article/details/124243735

版权

本文详细介绍了Java中的异常处理机制，包括异常的概述、分类（系统异常、运行时异常）、捕获处理（try...catch和finally代码块）以及如何在方法中抛出异常。强调了异常处理的原则，提倡合理使用异常，避免过度捕获。此外，还探讨了自定义异常的创建和使用场景，以提升程序的健壮性和可读性。

摘要由CSDN通过智能技术生成

8.3.1 try...catch 代码块

8.3.2finally代码块

8.4 在方法中抛出异常

8.4.1使用throws关键词抛出异常

8.4.2 使用throws关键词抛出异常

8.5自定义异常

8.6 异常的使用原则

8.1异常概述

在程序中，错误可能产生于程序员没有预料到的各种情况，或者是超出了程序员可控范围的环境因素，如试图打开一个根本不存在的文件等

在 Java中，这种在程序运行时可能出现的一些错误称为异常。Java语言的异常处理机制优势之一就是可以将异常情况在方法调用中进行传递，通过传递可以将异常情况传递到合适的位置再进行处理，这种机制类似于现实中发现了火灾，一个人是无法扑灭大火的，那么可以将这种异常情况传递给119，119 再将这个情况传递给附近的消防队，消防队及时赶到并进行灭火。使用这种处理机制，使得Java语言的异常处理更加灵活，Java语言编写的项目更加稳定。当然，异常处理机制也存在一些弊端，例如，使用异常处理可能会降低程序的执行效率，增加语法复杂度等。

throwable

errorn 错误

exception 异常

运行时异常是 runTimeException类及其子类

非运行时异常是 runTimeException类及其子类以外的异常

例8.1

代码

结果

程序运行的结果报告发生了算术异常Arithn neticException(根据给出的错误提示可知发生错误是
因为在算术表达式“3/0”中，0作为除数出现) 系统不再执行下去，提前结束。这种情况就是所说
的异常。有许多异常的例子，如空指针、数组溢出等。由于 Java 语言是一门面向对象的编程语言，因此异常在Java式。某一方法中发生错误时，这个方法会创建个对象，并且把它传递给正在运行的系统。这个对象就是异常对象。通过异常处理机制，可以将非正常情况下的处理代码与程序的主逻辑分离，即在编写代码主流程的同时在其他地方处理异常。

8.2异常的分类

Exception是程序本身可以处理的异常，这种异常主要分为运行行时异常和非运行时异常，程序中应当尽可能去处理这些异常，本节将分别对这两种异常进行讲解。
1.运行时异常
运行时异常是程序运行过程中产生的异常，它是Runtime Exception 类及其子类异常，如
NullPointerException、IndexOutOfBoundsException等，这些异常般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
所示。 Java中提供了常见的RuntimeException异常，这些异常可通道过try...catch语句捕获，如表

8.2.1系统异常

Java类库的每个包中都定义了异常类，所有这些类都是 Throwable 类的子类。Throwable 类派生了两个子类，分别是 Error 类和Exception类，其中，Error类及其子类用来描述Java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重。Exception 类称为非致命性类，可以通过捕捉处理使程序继续执行。Exception 类又可以根据错误发生的原因分为运行时异常和非运行时异常。
由的异常类继承体系如图所示。

代码

结果

8.2.2异常 Exception

运行时的异常类型（关键字）

例8.2

代码

public class BBB2 {//创建类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		String str ="lili";//定义字符串
		System.out.println(str+"年龄是：");  //输出的提示信息
		int age = Integer.parseInt("20l");   //数据类型的转换
		 System.out.println(age);            //输出信息
	}

}

结果

例8.3

代码

public class BBB3 {          //创建类
	private  int playerNum;        //定义“球员数量”
	private   String    teamName;        //定义“球队名称”
	public  BBB3() throws ClassNotFoundException       //构造方法BBB3()
	{
		//寻找“教练”类
				Class.forName("com.mrsoft.Coach");//捕捉错误信息
	}
	public static void main(String[] args) {//主函数
		BBB3 team = new BBB3();   //new新的对象
		 team.teamName = "com.mrsoft";//初始化信息
		 team.playerNum = 19;//初始化信息
		 System.out.println("\n球队名称:"+team.teamName+"\n"+"球员数量:"+team.playerNum +"名");
	}//输出结果

}

结果

8.3捕捉处理异常

try {
	  //程序代码
  }
  catch(Exceptiontype e) {
	  //对Exceptiontype的处理
  }
  finally {
	  //代码块
  }

8.3.1 try...catch 代码块

其中，try代码块中是可能发生异常的Java代码;catch代码块在try代码块之后，用来激发被捕获的异常;finally代码块是异常处理结构的最后执行部分，无论程序是否发生异常，finally代码块中的代码都将执行，因此，在 finally 代码块中通常放置一些释放资源、关闭对象的代码。
通过try…catch 代码块的语法可知，捕获处理异常分为try….catch 代码块和 finally 代码块两部分

例8.4

代码

public class BBB4 {//创建类
	public static void main(String[] args) {//主函数
		// TODO Auto-generated method stub
		try{                            // try语句中包含可能出现异常的程序代码
			String str = "lili";        //定义字符串常量
			 System.out.println(str+"年龄是："); //输出信息
			 int age = Integer.parseInt("20l");//数据类型转换
			 System.out.println(age); //输出年龄信息
		}catch(Exception e) {					//catch代码块用来获取异常信息
			e.printStackTrace();			//输出异常性质
		}
		 System.out.println("program over");   //输出信息
		}
	}

结果

Exception对象还提供了其他的方法用于获取异常的如下：

getMessage()方法: 获取有关异常事件的信息。
toString0)方法: 获取异常的类型与性质。
printStackTrace()方法: 获取异常事件发生时执行堆栈的内容

程序仍然输出最后的提示信息，没有因为异常而终止。在例 8.4 中将可能出现异常的代码用trac代进行理，tr代码中语句发生异常时，程序就会跳转到catch代码块中执行，执行catch代码中的程代码后，将继续执行catch码，而不会执行try代码块中发生异常语句后面的代码。由此可知，Java的异常处理是结构化的，不会因为一个异常影响整个程序的执行。
上面代码中，在catch代码块中使用了Exception对象的printStackTrace()方法输出了异常的栈日志，除此之外，Exception对象还提供了其他的方法用于获取异常的相关信息，其最常用的3个方法如下。

(1)getMessage0方法:获取有关异常事件的信息。

(2)toStringO方法:获取异常的类型与性质。
(3)printStackTrace0)方法:获取异常事件发生时执行堆栈的内容。

注意:
有时为了编程简单会忽略catch代码块后的代码，这样try…catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会导致最终运行结果与期望的不一致，而错误发生的原因很难查找。因此要养成良好的编程习惯，最好在catch代码块中写入处理异常的代码。
在例8.4中，虽然try代码块后面用了一个catch代码块来捕捉异常，但是遇到需要处理多种异常信息的情况时，可以在一个try代码后面多catch代码块。这里需要注意的是，如果使用多个catch 代码块，则catch 代码块中的异常类顺序是先子类后父类，因为父类的引用可以引用子类的对象。

8.3.2finally代码块

例8.5

代码

public class BBB5 {//创建类
	public static void main(String[] args) {//主函数
		// TODO Auto-generated method stub
		try{            // try语句中包含可能出现异常的程序代码
			String str = "lili";  //定义字符串常量
			 System.out.println(str+"年龄是：");   //输出信息
			 int age = Integer.parseInt("20l");   //数据类型转换
			 System.out.println(age);     //输出年龄信息
		}catch(Exception e) {					//catch代码块用来获取异常信息
			e.printStackTrace();			//输出异常性质
		}finally {                         //最后，finally关键词
		 System.out.println("program over");  //输出信息
	}

}
}

结果

程序在捕捉完异常信息之后，会执行finally代码中的代码。

在以下3种特殊情况下，finally块不会被执行

在finally代码块中发生了异常。
在前面的代码中使用了System.exit（）退出程序
程序所在的线程死亡。

8.4 在方法中抛出异常

8.4.1使用throws关键词抛出异常

例8.6

代码

public class BBB6 {//创建类
	static void pop() throws NegativeArraySizeException { // 定义方法并抛出NegativeArraySizeException异常
		  int[] arr = new int[-3]; // 创建数组
		 }

		 public static void main(String[] args) { // 主方法
		  try {                    // try语句处理异常信息
		   pop();                    // 调用pop()方法
		  } catch (NegativeArraySizeException e) {   //抛出NegativeArraySizeException 异常信息
		   System.out.println("pop()方法抛出的异常"); // 输出异常信息
		  }
		 }
		}

结果

注意:
用throws 为方法抛出异常时，如果子类继承父类，子类重写方法抛出的异常也要和原父类方法抛出的异常同或是其异常的子类，除非 throws 异常是RuntimeException。

8.4.2 使用throws关键词抛出异常

例8.7

代码

public static void main(String[] args) { // 主方法
		  int num1 = 25;     //定义初值
		  int num2 = 0;			//定义初值
		  int result;         //定义初值
		  if (num2 == 0) // 判断num2是否等于0，如果等于0，抛出异常
		  {
		   
		   throw new ArithmeticException("这都不会，小学生都知道：除数不能是0！！！");
		  }// 抛出ArithmeticException异常
		  result = num1 / num2; // 计算int1除以int2的值
		  System.out.println("两个数的商为：" + result);//输出两个数的商
		 }
		}

结果

throws关键字和throw关键字的区别如下。
(1)throws用在方法声明后面，表示抛出异常，由方法的调用者处理，而throw用在方法体内，用来制造一个异常，由方法体内的语句处理。
(2)throws是声明这个方法会抛出这种类型的异常，以便使它的调用者知道要捕获这个异常，而 throw是直接抛出一个异常实例。
(3)throws表示出现异常的一种可能性，并不一定会发生这些异常，如果使用throw，就一定会产生某种异常。

8.5自定义异常

在程序中使用自定义异常类，大体可分为以下几个步骤

(1)创建自定义异常类。
(2)在方法中通过throw关键字抛出异常对象。
(3)如果在当前抛出异常的方法中处理异常，可以使用try…catch代码块捕获并处理，否则，在方法的声明处通过throws关键字指明要抛给方法调用者的异常，继续进行下一步操作。
(4)在出现异常方法的调用者中捕获并处理异常。有了自定义异常，再来解决年龄为负数的异常问题。

例8.8

代码

public class BBBB8 {  //定义方法，抛出自定义的异常
 static void avg(int age) throws BBB8{//抛出BBB8异常错误
  if(age<0) {      //判断方法中参数是否满足指定条件
   throw new BBB8("年龄不可以使用负数");//错误信息
   
  }else {                  //反之
   System.out.println("王师傅今年"+ age +"岁了!");//输出王师傅今年多少岁
}
}
   public static void main(String[] args) { // 主方法
    try {     //try代码块处理可能出现异常的代码
     avg(-50);              //负数
    }catch(BBB8 e) {   //捕捉错误信息
     
     e.printStackTrace();   //输出异常性质
    }
   }}

结果

自定义异常主要用在以下场合。
(1)使异常信息更加具体，比如跟别人合作开发时，程序出现了空指针异常，但别人可能不清楚这个空指针是如何产生的，这时即可自定义一个显示具体信息的异常，比如自定义一个用户信息为空时抛出的异常:NullOfUserlnfoException，当这个异常发生就代表用户填写的信息不完整。
(2)程序中有些错误是符合Java语法的，但不符合业务逻辑或者实际情况，比如程序中出现了一个人的年龄是负数、人员个数为小数等。
(3)在分层的软件架构中，通常在表现层统一对系统其他层次的异常进行捕获处理。

8.6 异常的使用原则

常处理不应该用来控制程序的正常流其主要作用是捕获程序在运行时发生的异常并进行相应的处理。编写代码处理某个方法可能出现异常时，可遵循以下原则。
(1)不要过度使用异常，虽然通过异常可以增强程序的健壮性，但如果使用过多不必要的异常处理，可能会影响程序的执行效率。
(2)不要使用过于庞大的 try...catch块。在一个try块中放置大量的代码。这种写法看上去“很简单”但是由于try块中的代码过于庞大，业务过于复杂，会造成try块中出现异常的可能性大大增加，从而导致分析异常原因的难度也大大增加。
(3)避免使用catch（Exception)。因为如果所有异常都采用相同的处理方式，将导致无法对同异常分情况处理;另外，这种捕获方式可能将程序中的全部错误，异常捕获到，这时如果出现些“关键”异常，可能会被“悄悄地”忽略掉。
(4)不要忽略捕捉到的异常，遇到异常一定要及时处理。
(5)如果父类抛出多个异常，则覆盖方法必须抛出相同的异常或其异常的子类，不能抛出来异常。