软件构造课程笔记9——Java中的异常处理

1.异常类的层次

所有的异常类是从java.lang.Exception类继承的子类。

Exception类是Throwable类的子类，它有两个主要的子类：IOException类和RuntimeException类（只是“主要的”，除了这两个子类还有其他子类）。

除了Exception类外，Throwable类还有一个子类Error，用来指示运行时发生的错误。

2.检查性异常和非检查性异常

所有的检查性异常都继承自java.lang.Exception；所有的非检查性异常都继承自java.lang.RuntimeException。

检查性异常和非检查性异常最主要的区别在于处理异常的方式：检查性异常必须使用try-catch或throws等关键字进行处理，否则编译器会报错；非检查性异常一般是程序代码些的不够严谨而导致的问题，可以通过修改代码来规避。

常见的检查性异常：输入输出异常(IOException)、文件不存在异常(FileNotFoundException)、SQL语句异常(SQLException)等。

具体区分这两类异常的方法：如果除了输出报错信息没有其他可做的事（如跳转至某处指令/修改某些值），只能结束程序的话，那就属于非检查性异常。

3.捕获异常

try-catch关键字

使用try-catch关键字可以捕获异常，其语法如下：

try{
    //程序代码
}catch(ExceptionName e1){
    //Catch块
}
//实例：声明有两个元素的一个数组，当代码试图访问数组的第四个元素时会抛出异常
import java.io.*;
public class ExcepTest{
 
   public static void main(String args[]){
      try{
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}//当然这不是一个好例子，因为这属于非检查性异常，一般不需要捕获

一个try代码块后面跟随多个catch代码块的情况就叫多重捕获，其语法如下：

try{
   // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}catch(异常类型3 异常的变量名3){
  // 程序代码
}
//实例：如果保护代码中发生异常，异常会被抛给第一个catch块。如果抛出异常的数据类型与异常类型1匹配，它在这里就会被捕获；如果不匹配，它就会被传递给第二个catch块，如此直到异常被捕获或者通过所有的catch块
try {
    file = new FileInputStream(fileName);
    x = (byte) file.read();
} catch(FileNotFoundException f) { // Not valid!
    f.printStackTrace();
    return -1;
} catch(IOException i) {
    i.printStackTrace();
    return -1;
}

throws/throw关键字

throw代表动作，表示抛出一个异常的动作；throws代表一种状态，表示方法可能抛出异常。

throw用在方法实现中，抛出一个异常对象，而且只能是一个；throws用在方法声明中，抛出异常类，可以有多个。

throw用来在程序中明确地抛出异常；throws用来表明方法不能处理的异常。

如果一个方法可能发生但没有捕获到一个检查性异常，那么该方法必须在方法名的尾部使用throws关键字声明或者在方法体中使用throw关键字，来抛出该异常，无论它时新实例化的还是刚捕获到的。

//实例1：方法抛出一个RemoteException异常
import java.io.*;
public class className
{
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
}
//实例2：方法抛出多个异常，之间用逗号隔开
import java.io.*;
public class className
{
   public void withdraw(double amount) throws RemoteException,
                              InsufficientFundsException
   {
       // Method implementation
   }
   //Remainder of class definition
}

finally关键字

finally关键字用来创建在try代码块后面执行的代码块，无论是否发生异常，finally代码块中的代码总会被执行。一般在finally代码块中运行清理类型等收尾善后性质的语句，其语法如下：

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}
//实例：
public class ExcepTest{
  public static void main(String args[]){
    int a[] = new int[2];
    try{
       System.out.println("Access element three :" + a[3]);
    }catch(ArrayIndexOutOfBoundsException e){
       System.out.println("Exception thrown  :" + e);
    }
    finally{
       a[0] = 6;
       System.out.println("First element value: " +a[0]);
       System.out.println("The finally statement is executed");
    }
  }
}

4.声明自定义异常

在Java中可以自定义异常，在编写自定义的异常类时需要记住：

①所有异常都必须时Throwable的子类；②如果希望写一个检查性异常类，则需要继承Exception类；③如果希望写一个非检查性异常类，则需要继承RuntimeException类。

语法及实例如下：

//自定义异常类
class MyException extends Exception{
}
//只继承Exception类来创建的异常类时检查性异常类

//实例：模拟一个银行账户，通过银行卡的号码完成识别，可以进行存钱和取钱等操作

// 文件名InsufficientFundsException.java
import java.io.*;
 
//自定义异常类，继承Exception类
public class InsufficientFundsException extends Exception
{
  //此处的amount用来储存当出现异常（取出钱多于余额时）所缺乏的钱
  private double amount;
  public InsufficientFundsException(double amount)
  {
    this.amount = amount;
  } 
  public double getAmount()
  {
    return amount;
  }

//展示如何使用自定义异常类：
// 文件名称 CheckingAccount.java
import java.io.*;
 
//此类模拟银行账户
public class CheckingAccount
{
  //balance为余额，number为卡号
   private double balance;
   private int number;
   public CheckingAccount(int number)
   {
      this.number = number;
   }
  //方法：存钱
   public void deposit(double amount)
   {
      balance += amount;
   }
  //方法：取钱
   public void withdraw(double amount) throws
                              InsufficientFundsException
//在这里抛出了我们自定义的异常类
   {
      if(amount <= balance)
      {
         balance -= amount;
      }
      else
      {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
  //方法：返回余额
   public double getBalance()
   {
      return balance;
   }
  //方法：返回卡号
   public int getNumber()
   {
      return number;
   }
}

//展示如何调用抛出我们自定义异常类的方法：
//文件名称 BankDemo.java
public class BankDemo
{
   public static void main(String [] args)
   {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500...");
      c.deposit(500.00);
      try
      {
         System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600...");
         c.withdraw(600.00);
      }catch(InsufficientFundsException e)//需要对我们自定义的检查性异常类进行捕获
      {
         System.out.println("Sorry, but you are short $"
                                  + e.getAmount());
         e.printStackTrace();
      }
    }
}