位置:首页 > Java技术 > Java在线教程 > Java异常处理

Java异常处理

异常是一个问题的程序的执行期间产生了。异常可能会发生许多不同的原因,包括以下内容:

  • 用户输入无效数据。

  • 需要打开的文件不存在。

  • 网络连接已丢失通信的中间或JVM已经耗尽内存。

有些例外的是由用户错误,其他人造成的程序员的错误,和其他人的失败以某种方式物理资源。

要了解在Java中如何异常处理工作,需要了解三类异常:

  • 检查异常: 经过检查的异常是一个例外,通常是用户错误或不能由程序员不可预见的问题。例如,如果一个文件被打开,但该文件无法找到,则会出现异常。这些例外并不能简单地在编译时被忽略。

  • 运行时异常: 运行时异常是发生,大概本来是可以避免程序员异常。而不是已检查异常,运行时异常是在编译时被忽略。

  • 错误: 这些都不例外可言,但所出现超出用户或程序员的控制问题。错误通常忽略了你的代码,因为你可以很少做任何有关错误。例如,如果发生堆栈溢出时,会产生一个错误。他们还忽略了在编译的时候。

异常层次结构:

所有异常类是java.lang.Exception类的子类型。异常类是的Throwable类的子类。以外的异常类有另一个小类称为错误这是从Throwable的类中派生。

错误,一般都不会被困形成的Java程序。这些情况通常发生在出现严重故障,这不是由java程序处理。产生错误指示运行时环境中产生错误。例如:JVM是内存不足。通常的程序不能从错误中恢复。

Exception类主要有两个子类:IOException类和RuntimeException异常类。

Java Exceptions

下面是最常见的选中和未选中列表 Java内置异常.

异常的方法:

以下是在Throwable类中提供重要的方法列表。

SN 方法及描述
1 public String getMessage()
返回有关已发生的异常的详细消息。此消息在Throwable的构造函数中初始化。
2 public Throwable getCause()
返回异常由一个Throwable对象所代表的原因。
3 public String toString()
返回类连接在一起的getMessage()结果的名称。
4 public void printStackTrace()
打印toString()结果以及堆栈跟踪到System.err,错误输出流的结果。
5 public StackTraceElement [] getStackTrace()
返回包含在堆栈跟踪每一个元素的数组。索引为0的元素表示的调用堆栈的顶部,并在阵列中的最后一个元素表示的方法在调用堆栈的底部。
6 public Throwable fillInStackTrace()
填补了这个Throwable对象的堆栈跟踪与当前的堆栈跟踪,增加在堆栈跟踪以前的任何信息。

捕获异常:

一种捕获的方法是使用try和catch关键字的组合异常。try/ catch块放在围绕之中,可能产生异常的代码。try/catch块中的代码被称为受保护的代码,以及语法使用try/catch语句如下所示:

try
{
   //Protected code
}catch(ExceptionName e1)
{
   //Catch block
}

catch语句涉及声明异常的正在试图捕捉类型。如果受保护的代码发生异常,catch块(或块)后面的试一下检查。如果发生异常的类型列在catch块,异常被传递到catch块多作为一个参数被传递到方法参数。

例子:

下面是一个数组并有2个元素声明。然后代码试图访问它抛出一个异常数组的第三个元素。

// File Name : 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

多个catch块:

一个try块后面可以跟多个catch块。多个catch代码块语法如下所示:

try
{
   //Protected code
}catch(ExceptionType1 e1)
{
   //Catch block
}catch(ExceptionType2 e2)
{
   //Catch block
}catch(ExceptionType3 e3)
{
   //Catch block
}

前面的语句演示3个catch块,但可以有任意数量的其中的一个try后。如果受保护的代码发生异常,该异常被抛出到列表中的第一个catch块。如果抛出的异常的数据类型相匹配ExceptionType1,它就会被捕获那里。如果不是,则该异常传递到第二catch语句. 这种情况持续下去,直到异常要么被捕获或下落通过全部捕获,在这种情况下,目前的方法停止执行并抛出异常下落到以前的方法调用堆栈。

例子:

下面是代码段展示了如何使用多个try/catch语句。

try
{
   file = new FileInputStream(fileName);
   x = (byte) file.read();
}catch(IOException i)
{
   i.printStackTrace();
   return -1;
}catch(FileNotFoundException f) //Not valid!
{
   f.printStackTrace();
   return -1;
}

throws/throw 关键字:

如果一个方法不处理未处理异常,该方法必须使用throw关键字声明它。在抛出的关键字出现在方法签名的结束。

可以抛出一个异常,或者是一个新实例化刚刚捕获的异常,使用throw关键字。试着去了解不同的抛出异常和throw关键字。

下面的方法声明它会抛出一个RemoteException:

import java.io.*;
public class className
{
   public void deposit(double amount) throws RemoteException
   {
      // Method implementation
      throw new RemoteException();
   }
   //Remainder of class definition
}

一个方法可以声明它抛出多个异常,在这种情况下,异常都是在以逗号分隔的列表中声明。例如,下面的方法声明它会抛出一个RemoteException和InsufficientFundsException:

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块可以运行要执行代码,不管在受保护的代码会发生什么,可用于清理工作类型语句。

finally块出现在catch块的结尾并具有以下语法:

try
{
   //Protected code
}catch(ExceptionType1 e1)
{
   //Catch block
}catch(ExceptionType2 e2)
{
   //Catch block
}catch(ExceptionType3 e3)
{
   //Catch block
}finally
{
   //The finally block always executes.
}

例子:

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语句。

  • 它不是强制性的有finally子句时,总会有一个try / catch块存在。

  • try块中不能出现没有任何catch子句或finally子句。

  • 任何代码不能出现在 try, catch, finally 块之间。

声明自己的异常:

可以在Java中创建自己的异常。编写自己的异常类时请注意以下几点:

  • 所有的异常必须是Throwable的子类。

  • 如果想写一个检查异常是处理自动执行或声明规则,需要扩展Exception类。

  • 如果想编写一个运行时异常,则需要扩展RuntimeException类。

我们可以定义如下自己的异常处理类:

class MyException extends Exception{
}

只需要扩展Exception类来创建自己的异常类。这些被认为是已检查异常。下面InsufficientFundsException类是扩展了Exception类,使其成为检查的异常用户定义的异常。一个异常类是像任何其他类,包含有用的字段和方法。

例子:

// File Name InsufficientFundsException.java
import java.io.*;

public class InsufficientFundsException extends Exception
{
   private double amount;
   public InsufficientFundsException(double amount)
   {
      this.amount = amount;
   } 
   public double getAmount()
   {
      return amount;
   }
}

为了证明我们的使用用户定义的异常,下面的CheckingAccount类包含一个withdraw() 方法抛出一个InsufficientFundsException。 

// File Name CheckingAccount.java
import java.io.*;

public class CheckingAccount
{
   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程序演示调用deposit()和withdraw() 方法。

// File Name 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("
Withdrawing $100...");
         c.withdraw(100.00);
         System.out.println("
Withdrawing $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 异常: - 这些是完全或逻辑抛出由JVM异常/错误。例如:NullPointerException异常,ArrayIndexOutOfBoundsException异常,抛出ClassCastException,

  • 编程异常: - 这些异常是由应用程序或API编程实例明确地抛出,如:IllegalArgumentException, IllegalStateException.