Java【异常处理】

机制概述

JVM用方法调用栈来跟踪一系列方法的调用过程，位于栈顶的是正在执行的方法，当一个方法抛出异常时，根据代码处理异常。

异常常见类型 

• 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这些异常在编译时强制要求程序员处理。
• 运行时异常： 这些异常在编译时不强制要求处理，通常是由程序中的错误引起的，例如 NullPointerException、ArrayIndexOutOfBoundsException 等，这类异常可以选择处理，但并非强制要求。
• 错误： 错误不是异常，而是脱离程序员控制的问题，错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

语法

异常处理的关键字和类

• try：用于包裹可能会抛出异常的代码块。
• catch：用于捕获异常并处理异常的代码块。
• finally：用于包含无论是否发生异常都需要执行的代码块。
• throw：用于手动抛出异常。
• throws：用于在方法声明中指定方法可能抛出的异常。
• Error类：是程序无法处理的错误，表示应用程序运行时环境发生的中的错误。如JVM 内存溢出。
• Exception类：是程序本身可以处理的异常，可以分为运行时异常或编译异常，它提供了一些方法来获取异常信息。

try-catch捕获异常

使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。

try {

    // 程序代码

}catch(ExceptionName e1) {

    //Catch 块

}

Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数的方法是一样。

示例：

// 文件名 : ExcepTest.java
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[2]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

多重捕获块

try{
   // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}catch(异常类型3 异常的变量名3){
  // 程序代码
}

示例：

try {
   //创建一个 FileInputStream 对象，用于从名为 fileName 的文件中读取数据
   file = new FileInputStream(fileName); 
   //调用 read() 方法从文件中读取一个字节的数据，并将其强制转换为 byte 类型，存储在变量 x 中
   x = (byte) file.read();
} catch(FileNotFoundException f) { //指定的文件不存在
   f.printStackTrace();
   return -1;
} catch(IOException i) { //在读取文件时发生其他 I/O 错误
   i.printStackTrace();
   return -1;
}

throw/throws处理异常

throw 关键字用于在代码中抛出异常，而 throws 关键字用于在方法声明中指定可能会抛出的异常类型。

示例：

//判断 num 是否小于 0，如果是，则抛出一个 IllegalArgumentException 异常
public void checkNumber(int num) {
  if (num < 0) {
    throw new IllegalArgumentException("Number must be positive");
  }
}

//当 readFile 方法内部发生 IOException 异常时，会将该异常传递给调用该方法的代码
public void readFile(String filePath) throws IOException {
  BufferedReader reader = new BufferedReader(new FileReader(filePath));
  String line = reader.readLine();
  while (line != null) {
    System.out.println(line);
    line = reader.readLine();
  }
  reader.close();
}

throw和throws的区别：

throw指人为地抛出一个异常对象，throws在方法上声明使用，表示这些方法将给被调处处理。throw出现在函数体，throws出现在方法函数头。执行throw一定出现了某种异常，而throws表示出现异常一种可能性，不一定会发生异常。两者都是消极方式，只是抛出异常，不会处理异常，真正处理异常由函数的上层调用完成。

finally关键字

finally 用来创建在 try 代码块后面执行的代码块。无论是否发生异常，finally 代码块中的代码总会被执行。finally 代码块出现在 catch 代码块最后，在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。try 代码后不能既没 catch 块也没 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");
    }
  }
}

try-with-resource 语法结构

JDK7后新增的。try-with-resources 机制旨在自动管理资源，确保资源在使用后能够及时关闭，避免资源泄露 。它能够自动关闭在 try 块中声明的资源，无需显式地在 finally 块中关闭。在 try-with-resources 语句中，只需要在 try 关键字后面声明资源，然后跟随一个代码块。无论代码块中的操作是否成功，资源都会在 try 代码块执行完毕后自动关闭。

try (resource declaration) {
  // 使用的资源
} catch (ExceptionType e1) {
  // 异常块
}

示例：

import java.io.*;

public class RunoobTest {

    public static void main(String[] args) {
    //声明一个字符串变量 line，用于存储读取的每一行内容
    String line;
        //使用 try-with-resources 语句创建一个 BufferedReader 对象 br，用于读取文件 test.txt
        try(BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            //使用 while 循环逐行读取文件内容。readLine() 方法返回当前行的内容，如果到达文件末尾，将返回 null
            while ((line = br.readLine()) != null) {
                System.out.println("Line =>"+line);
            }
        } catch (IOException e) { //捕获可能出现的 IOException
            //打印异常信息
            System.out.println("IOException in try block =>" + e.getMessage());
        }
    }
}

异常类

Java 的非检查性异常类

Java的检查性异常类

自定义异常

规则

• 所有异常都必须是 Throwable 的子类。
• 如果希望写一个检查性异常类，则需要继承 Exception 类。
• 如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。

Throwable 类的主要方法

示例：

// 文件名称 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;
   }
}