第八章异常处理总结

原创于 2022-04-29 23:32:22 发布 · 129 阅读

CC 4.0 BY-SA版权

文章标签：

本文详细介绍了Java异常处理的概念，包括异常的分类，如Error和Exception，以及它们的区别。异常处理的优势在于能够将错误信息传递到合适的位置进行处理，但同时也可能导致性能下降和语法复杂度增加。文章通过实例讲解了运行时异常和非运行时异常，如NullPointerException和IOException，并展示了如何使用try...catch和finally语句进行异常捕获和处理。此外，还探讨了在方法中使用throws和throw关键字抛出异常，以及自定义异常的重要性。最后，提出了异常处理的使用原则，强调了不应过度使用异常和避免忽略捕获的异常。

8.1 异常概述

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

package java7;

public class Baulk {//创建类
	public static void main(String[] args) { // 主方法
		  int result = 3 / 0; // 定义int型变量并赋值
		  System.out.println(result); // 将变量输出
		 }
}

运行结果：

8.2 异常分类

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

8.2.1 系统错误——Error

Error类及其子类通常用来描述Java运行系统中的内部错误，该类定义了常规环境下不希望由程序捕获的异常，比如OutOfMemoryError、ThreadDeath等，这些错误发生时，Java虚拟机(JVM)一般会选择线程终止。

例如，下面的代码在控制台中输出“梦想照亮现实”这句话，代码如下图：

public static void main(String[] args) {
	    System.out.println("梦想照亮现实!!!") //此化处缺少必要的分号
	}
}

运行结果:

8.2.2 异常——Exception

Exception是程序本身可以处理的异常，这种异常主要分为运行时异常和非运行时异常，程序中应当尽可能去处理这些异常，

1. 运行时异常

运行时异常是程序运行过程中产生的异常，它是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
Java中提供了常见的RuntimeException异常，这些异常可通过try..catch语句捕获，如表8.1所示:

例如，将一个字符串转换为整型，可以通过Integer类的parselnt()方法来实现。如果该字符串不是数字形式，parseInt()方法就会显示异常，程序将在出现异常的位置终止，不再执行下面的语句。

package java7;

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

}

运行结果：

从上图中运行结果可以看出，本实例报出的是NumberFormatException(字符串转换为数字)异常，该异常实质上是由于开发人员的逻辑错误造成的。

2.非运行时异常
非运行时异常是RuntimeException类及其子类异常以外的异常。从程序语法角度讲，这类异常是必须进行处理的异常，如果不处理，程序就不能编译通过，如IOException、 SQLException以及用户自定义的异常等。
Java中常见的非运行时异常类如表8.2所示：

package java7;

public class FootballTeam {
	 private int playerNum;  //定义球员数量
	 private String teamName; //定义“球员名称”
	 public  FootballTeam()
	 {
	  //寻找教练类
	  Class.forName("com.mrsoft.Coach");
	 }
	 
	 public static void main(String[] args) {
	  // TODO Auto-generated method stub
	   FootballTeam team = new  FootballTeam();//创建对象team
	   team.teamName = "com.mrsoft";//初始化对象
	   team.playerNum = 19;//初始化对象
	   System.out.println("\n球队名称: " + team.teamName + "\n" + "球员数量: " + team.playerNum + "名");
	 
	 }
}

解决方案：

单击编译器给出的两种方案，代码会自动更正。

public class FootballTeam {
 private int playerNum;  //定义球员数量
 private String teamName; //定义“球员名称”
 public  FootballTeam()
 {
  //寻找教练类
 
 
    try {
 
       Class.forName("com.mrsoft.Coach");
  } catch (ClassNotFoundException e) {
       //TODO Auto-generated catch block
         e.printStackTrace();
    }
}
 
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
   FootballTeam team = new  FootballTeam();//创建对象team
   team.teamName = "com.mrsoft";//初始化对象
   team.playerNum = 19;//初始化对象
   System.out.println("\n球队名称: " + team.teamName + "\n" + "球员数量: " + team.playerNum + "名");
 
 }
 
}

8.3 捕捉处理异常

系统会自动为非运行时异常提供两种解决方案，一种是使用throws关键字，一种是使用try...catch代码块，这两种方法都是用来对异常进行处理的，本节首先对try...catch代码块进行讲解。
try...catch 代码块主要用来对异常进行捕捉并处理。在实际使用时，该代码块还有一个可选的finally代码块，其标准语法如下：

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

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

8.3.1 try...catch代码块

package java7;

public class Take {//创建类
	public static void main(String[] args) { //主方法
		  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");   //输出信息
		       }
}

运行结果：

8.3.2 finally代码块

完整的异常处理语句应该包含finally代码块，通常情况下，无论程序中有无异常发生，finally代码块中的代码都可以正常执行。

package java7;

public class Take {// 创建类
	 public static void main(String[] args) {
	  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 {
	  System.out.println("program  over"); // 输出信息
	 }
	}
}

运行结果：

8.4 在方法中抛出异常

如果某个方法可能会发生异常，但不想在当前方法中处理这个异常，则可以使用throws、throw关键字在方法中抛出异常，本节将对如何在方法中抛出异常进行讲解。

8.4.1 使用throws 关键字抛出异常

返回值类型名方法名（参数表）throws 异常类型名 {

方法体

}

package java7;

public class Shoot {  //创建类
	static void pop() throws NegativeArraySizeException {
		  //定义方法并抛出NegativeArraySizeException异常
		  int[] arr = new int[-3];       //创建数组
		 }
		 
		 public static void main(String[] args) {  //主方法
		  // TODO Auto-generated method stub
		         try {                                //try语句处理异常信息 
		          pop();                           //调用pop()方法
		         } catch (NegativeArraySizeException e) {
		          System.out.println("pop()方法抛出的异常");  //输出异常信息
		         }
		           
		     }
}

运行结果：

8.4.2 使用 throw 关键字抛出异常

throw关键字通常用于在方法体中“制造”一个异常，程序在执行到throw语句时立即终止，它后面的语句都不执行。使用throw关键字抛出异常的语法格式为：

throw new 异常类型名(异常信息)

throw 通常用于在程序出现某种逻辑错误时，由开发者主动抛出某种特定类型的异常，下面通过一个实例介绍throw的用法。

package java7;

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

运行结果：

8.5 自定义异常

使用Java内置的异常类可以描述在编程时出现的大部分异常情况，但是有些情况是通过内置异常类无法识别的，例如，下面的一段代码：

int age =-50;

System.out.print1n(”王师傅今年 ”+age+”岁了！”)；

上面代码运行时没有任何问题，但是大家想一想：人的年龄可能是负数吗？这类问题编译器是无法识别的，但很明显不符合常理，那么，对于这类问题即可通过自定义异常对它们进行处理。Java中可以通过继承Exception类自定义异常类。

public class MyException extends Exception {   //创建自定义异常，继承Exception类
     public  MyException(String ErrorMessage) {  //构造方法
          super(ErrorMessage);                  //父类构造方法
   }
}

package java7;

import java.awt.color.CMMException;

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

运行结果：

8.6 异常的使用原则

Java异常强制用户去考虑程序的强健性和安全性。异常处理不应该用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应的处理。编写代码处理某个方法可能出现的异常时，可遵循以下原则：

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