Java 异常处理 |

link之家

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

Exception 类的层次

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

Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。

Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。

Error 用来指示运行时环境发生的错误。

例如，JVM 内存溢出。一般地，程序不会从错误中恢复。

异常类有两个主要的子类：IOException 类和 RuntimeException 类。

Java 内置异常类

Java 语言定义了一些异常类在 java.lang 标准包中。

标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的，所以大部分从运行时异常类继承而来的异常都可以直接使用。

Java 根据各个类库也定义了一些其他的异常，下面的表中列出了 Java 的非检查性异常。使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。

try/catch代码块中的代码称为保护代码，使用 try/catch 的语法如下： // 程序代码 }catch(ExceptionName e1) //Catch 块

Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。

如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。

下面的例子中声明有两个元素的一个数组，当代码试图访问数组的第四个元素的时候就会抛出一个异常。

ExcepTest.java 文件代码：

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

以上代码编译运行输出结果如下：

Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3 Out of the block

多重捕获块

一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获。

多重捕获块的语法如下所示：

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

上面的代码段包含了 3 个 catch块。

可以在 try 语句后面添加任意数量的 catch 块。

如果保护代码中发生异常，异常被抛给第一个 catch 块。

如果抛出异常的数据类型与 ExceptionType1 匹配，它在这里就会被捕获。

如果不匹配，它会被传递给第二个 catch 块。

如此，直到异常被捕获或者通过所有的 catch 块。

该实例展示了怎么使用多重 try/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 ;

在Java中， throw 和 throws 关键字是用于处理异常的。

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

throw 关键字

throw 关键字用于在当前方法中抛出一个异常。

通常情况下，当代码执行到某个条件下无法继续正常执行时，可以使用 throw 关键字抛出异常，以告知调用者当前代码的执行状态。

例如，下面的代码中，在方法中判断 num 是否小于 0，如果是，则抛出一个 IllegalArgumentException 异常。

public void checkNumber ( int num ) {
if ( num < 0 ) {
throw new IllegalArgumentException ( "Number must be positive" ) ;

throws 关键字

throws 关键字用于在方法声明中指定该方法可能抛出的异常。当方法内部抛出指定类型的异常时，该异常会被传递给调用该方法的代码，并在该代码中处理异常。

例如，下面的代码中，当 readFile 方法内部发生 IOException 异常时，会将该异常传递给调用该方法的代码。在调用该方法的代码中，必须捕获或声明处理 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 ( ) ;

一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。

例如，下面的方法声明抛出 RemoteException 和 InsufficientFundsException：

import java . io .*; public class className public void withdraw ( double amount ) throws RemoteException , InsufficientFundsException // Method implementation // Remainder of class definition

finally 关键字用来创建在 try 代码块后面执行的代码块。

无论是否发生异常，finally 代码块中的代码总会被执行。

在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。

finally 代码块出现在 catch 代码块最后，语法如下：

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

ExcepTest.java 文件代码：

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 " ) ;

以上实例编译运行结果如下：

Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3 First element value: 6 The finally statement is executed

注意下面事项：

catch 不能独立于 try 存在。

在 try/catch 后面添加 finally 块并非强制性要求的。

try 代码后不能既没 catch 块也没 finally 块。

try, catch, finally 块之间不能添加任何代码。

try-with-resources

JDK7 之后，Java 新增的 try-with-resource 语法糖来打开资源，并且可以在语句执行完毕后确保每个资源都被自动关闭。

try-with-resources 是一种异常处理机制，它可以简化资源管理代码的编写。

JDK7 之前所有被打开的系统资源，比如流、文件或者 Socket 连接等，都需要被开发者手动关闭，否则将会造成资源泄露。

try (resource declaration) {
  // 使用的资源
} catch (ExceptionType e1) {
  // 异常块
以上的语法中 try 用于声明和实例化资源，catch 用于处理关闭资源时可能引发的所有异常。
注意：try-with-resources 语句关闭所有实现 AutoCloseable 接口的资源。
import java.io.*;

public class RunoobTest {

    public static void main(String[] args) {

    String line;

        try(BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {

            while ((line = br.readLine()) != null) {

                System.out.println("Line =>"+line);

        } catch (IOException e) {

            System.out.println("IOException in try block =>" + e.getMessage());

以上实例输出结果为：
IOException in try block =>test.txt (No such file or directory)
以上实例中，我们实例一个 BufferedReader 对象从 test.txt 文件中读取数据。
在 try-with-resources 语句中声明和实例化 BufferedReader 对象，执行完毕后实例资源，不需要考虑 try 语句是正常执行还是抛出异常。
如果发生异常，可以使用 catch 来处理异常。

再看下不使用 try-with-resources 而改成 finally 来关闭资源，整体代码量多了很多，而且更复杂繁琐了：
import java.io.*;

class RunoobTest {

    public static void main(String[] args) {

        BufferedReader br = null;

        String line;

        try {

            System.out.println("Entering try block");

            br = new BufferedReader(new FileReader("test.txt"));

            while ((line = br.readLine()) != null) {

            System.out.println("Line =>"+line);

        } catch (IOException e) {

            System.out.println("IOException in try block =>" + e.getMessage());

        } finally {

            System.out.println("Entering finally block");

            try {

                if (br != null) {

                    br.close();

            } catch (IOException e) {

                System.out.println("IOException in finally block =>"+e.getMessage());

以上实例输出结果为：
Entering try block
IOException in try block =>test.txt (No such file or directory)
Entering finally block
try-with-resources 处理多个资源
try-with-resources 语句中可以声明多个资源，方法是使用分号 ; 分隔各个资源：
import java.io.*;

import java.util.*;

class RunoobTest {

    public static void main(String[] args) throws IOException{

        try (Scanner scanner = new Scanner(new File("testRead.txt")); 

            PrintWriter writer = new PrintWriter(new File("testWrite.txt"))) {

            while (scanner.hasNext()) {

                writer.print(scanner.nextLine());

以上实例使用 Scanner 对象从 testRead.txt 文件中读取一行并将其写入新的 testWrite.txt 文件中。
多个声明资源时，try-with-resources 语句以相反的顺序关闭这些资源。 在本例中，PrintWriter 对象先关闭，然后 Scanner 对象关闭。
声明自定义异常
在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。

	
所有异常都必须是 Throwable 的子类。
	如果希望写一个检查性异常类，则需要继承 Exception 类。
	如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。
可以像下面这样定义自己的异常类：
class MyException extends Exception{
只继承Exception 类来创建的异常类是检查性异常类。
下面的 InsufficientFundsException 类是用户定义的异常类，它继承自 Exception。
一个异常类和其它任何类一样，包含有变量和方法。
以下实例是一个银行账户的模拟，通过银行卡的号码完成识别，可以进行存钱和取钱的操作。
InsufficientFundsException.java 文件代码： 
// 文件名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 类中包含一个 withdraw() 方法抛出一个 InsufficientFundsException 异常。
CheckingAccount.java 文件代码： 
// 文件名称 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;
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
  //方法：返回余额
   public double getBalance()
      return balance;
  //方法：返回卡号
   public int getNumber()
      return number;
下面的 BankDemo 程序示范了如何调用 CheckingAccount 类的 deposit() 和 withdraw() 方法。
BankDemo.java 文件代码： 
//文件名称 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);
         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();
编译上面三个文件，并运行程序 BankDemo，得到结果如下所示：
Depositing $500...
Withdrawing $100...
Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException
        at CheckingAccount.withdraw(CheckingAccount.java:25)
        at BankDemo.main(BankDemo.java:13)
在Java中定义了两种类型的异常和错误。
	JVM(Java虚拟机) 异常：由 JVM 抛出的异常或错误。例如：NullPointerException 类，ArrayIndexOutOfBoundsException 类，ClassCastException 类。
	程序级异常：由程序或者API程序抛出的异常。例如 IllegalArgumentException 类，IllegalStateException 类。
		#0   veblen
  153***1086@qq.com




    
 146
名词解释：
1、检查性异常: 不处理编译不能通过
2、非检查性异常:不处理编译可以通过，如果有抛出直接抛到控制台
3、运行时异常: 就是非检查性异常
4、非运行时异常: 就是检查性异常
veblen   veblen
  153***1086@qq.com
6年前 (2017-04-14)

#0   为我所望
  190***9847@qq.com
 40
异常使用可遵循下面的原则：

1：在当前方法被覆盖时，覆盖他的方法必须抛出相同的异常或异常的子类；
2：在当前方法声明中使用try-catch语句捕获异常；
3：如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常。为我所望   为我所望
  190***9847@qq.com




    
6年前 (2017-05-29)

#0   doublefan
  187***60835@163.com
 167

如图可以看出所有的异常跟错误都继承与Throwable类，也就是说所有的异常都是一个对象。
从大体来分异常为两块：
1、error---错误 ： 是指程序无法处理的错误，表示应用程序运行时出现的重大错误。例如jvm运行时出现的OutOfMemoryError以及Socket编程时出现的端口占用等程序无法处理的错误。
2、Exception --- 异常 ：异常可分为运行时异常跟编译异常
1）运行时异常：即RuntimeException及其之类的异常。这类异常在代码编写的时候不会被编译器所检测出来，是可以不需要被捕获，但是程序员也可以根据需要进行捕获抛出。常见的RUNtimeException有：NullpointException（空指针异常），ClassCastException（类型转换异常），IndexOutOfBoundsException（数组越界异常）等。

2）编译异常：RuntimeException以外的异常。这类异常在编译时编译器会提示需要捕获，如果不进行捕获则编译错误。常见编译异常有：IOException（流传输异常），SQLException（数据库操作异常）等。

3、java处理异常的机制：抛出异常以及捕获异常 ，一个方法所能捕捉的异常，一定是Java代码在某处所抛出的异常。简单地说，异常总是先被抛出，后被捕捉的。
4、throw跟throws的区别:
public void test() throws Exception {
    throw new Exception();
从上面这一段代码可以明显的看出两者的区别。throws表示一个方法声明可能抛出一个异常，throw表示此处抛出一个已定义的异常（可以是自定义需继承Exception，也可以是java自己给出的异常类）。
5、接下来看一下如何捕获异常：
1）首先java对于异常捕获使用的是try---catch或try --- catch --- finally 代码块，程序会捕获try代码块里面的代码，若捕获到异常则进行catch代码块处理。若有finally则在catch处理后执行finally里面的代码。然而存在这样两个问题：
a.看如下代码：
    //待捕获代码
}catch（Exception e）{
    System.out.println("catch is begin");
    return 1 ；
}finally{
     System.out.println("finally is begin");
在catch里面有一个return，那么finally会不会被执行呢？答案是肯定的，上面代码的执行结果为：
catch is begin
finally is begin  
也就是说会先执行catch里面的代码后执行finally里面的代码最后才return1 ；
b.看如下代码：
   //待捕获代码    
}catch（Exception e）{
    System.out.println("catch is begin");
    return 1 ；
}finally{
     System.out.println("finally is begin");
     return 2 ;
在b代码中输出结果跟a是一样的，然而返回的是return 2 ； 原因很明显，就是执行了finally后已经return了，所以catch里面的return不会被执行到。也就是说finally永远都会在catch的return前被执行。（这个是面试经常问到的问题哦！）
6、对于异常的捕获不应该觉得方便而将几个异常合成一个Exception进行捕获，比如有IO的异常跟SQL的异常，这样完全不同的两个异常应该分开处理！而且在catch里处理异常的时候不要简单的e.printStackTrace()，而是应该进行详细的处理。比如进行console打印详情或者进行日志记录。
注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。
doublefan   doublefan
  187***60835@163.com
6年前 (2017-09-02)

#0   599069310
  599***310@qq.com
 20
Java 语言定义了一些异常类在 java.lang 标准包中。标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的，所以大部分从运行时异常类继承而来的异常都可以直接使用。

 * 异常:
 * finally不一定被执行，，例如 catch 块中有退出系统的语句 System.exit(-1); finally就不会被执行
import java.io.*;
public class Demo {
     * @param args
    public static void main(String[] args) {
        //检查异常1.打开文件
        FileReader fr=null;
        try {
            fr=new FileReader("d:\\aa.text");
            // 在出现异常的地方，下面的代码的就不执行
            System.out.println("aaa");
        } catch (Exception e) {
            System.out.println("进入catch");
            // 文档读取异常
            // System.exit(-1);
            System.out.println("message="+e.getLocalizedMessage());  //没有报哪一行出错
            e.printStackTrace();   // 打印出错异常还出现可以报出错先异常的行
        // 这个语句块不管发生没有发生异常，都会执行
        // 一般来说，把需要关闭的资源，文件，连接，内存等
        finally
            System.out.println("进入finally");
            if(fr!=null);
                try {
                    fr.close();
                } catch (Exception e) {
                    // TODO: handle exception
                    e.printStackTrace();
        System.out.println("OK");
}