韩震博客|关注于学习java&php与交流

Java异常以及处理原则

admin 2017年11月02日 Java知识 981 0

原则

Java的基本理念是“结构不佳的代码不能运行”。

发现错误的理想时机是在编译阶段,也就是在你试图运行程序之前。然而,编译期并不能找出所有的错误,余下的问题必须在运行期间解决。这就需要错误源能通过某种方式,把适当的信息传递给某个接收者——该接收者将知道如何正确的处理这个问题。

改进的错误恢复机制是提供代码健壮性的最强有力的方式。错误恢复在我们所编写的每一个程序中都是基本的要素,但是在Java中它显得格外重要,因为Java的主要目标之一就是创建他人使用的程序构件。要想创建健壮的系统,它的每一个构件都必须是健壮的。Java使用异常来提供一致的错误报告模型,使得构件能够与客户端代码可靠地沟通问题。

Java中的异常处理的目的在于通过使用少于目前数量的代码来简化大型、可靠的程序的生成,并且通过这种方式可以使你更加自信:你的应用中没有未处理的错误。

故障的代价

如果应用程序的异常处理方式既不连续又不通用会出现以下问题。

  • 扩展性和维护性不高:如果不采用标准处理模型,系统将难以修改。

  • 级联故障:如果对错误缺乏全局的直观认识,那么系统某一部分的错误可能扩展到整个应用程序。甚至可能导致一个或多个服务器崩溃,降低应用程序的可用性。

  • 处理不一致:如果缺少一个全局化组织模型,在处理异常时,开发人员可能作出与本团队其他人员冲突的决策。从而降低系统的整体有效性和可管理性。

  • 降低系统性能:如果处理不当,将引发无谓的系统调用和数据传输。从而降低系统的总体性能。

  • 丢失或损坏数据:局部化异常处理的副作用在于:通常很难与应用程序其他部分协调。这增加了问题的风险程度,从而损坏了业务模型,危及业务数据的完整性。

历史

异常处理起源于PL/1和Mesa之类的系统中,后来又出现在CLU、Smalltalk、Modula-3、Ada、Eiffel、C++、Python、Java以及后Java语言Ruby和C#中。Java的设计和C++很相似,只是Java的设计者去掉了一些他们认为C++设计得不好的东西。

为了能像程序员提供一个他们更愿意使用的错误处理和恢复的框架,异常处理机制很晚才被加入C++标准化过程中,这是由C++的设计者Bjarne Stroustrup所倡议的。C++的异常模型主要借鉴了CLU的做法。然而,当时其他语言已经支持异常处理了:包括Ada、Smalltalk(两者都有异常处理,但是都没有异常说明),以及Modula-3(它既有异常处理也有异常说明)。

Liskov和Snyder在它们的一篇讨论该主题的独创性论文1中指出,用瞬时风格(transient fashion)报告错误的语言(如C中)有一个主要缺陷,那就是:

……每次调用的时候都必须执行条件测试,以确定会产生何种结果。这使程序难以阅读,并且有可能降低运行效率,因此程序员既不愿指出,也不愿意处理异常。

C++中异常的设计参考了CLU方式。Stroustrup声称其目标是减少恢复错误所需要的代码。我想他这话是说给那些通常情况下都不写C的错误处理的程序员们听的,因为要把那么多代码放到那么多地方实在不是什么好差事。所以他们写C程序的习惯是,忽略所有的错误,然后使用调试器来跟踪错误。这些程序员知道,使用异常就意味着他们要写一些通常不用写的、“多出来的”代码。因此,要把他们拉到“使用错误处理”的正规上,“多出来的”代码决不能太多。

C++从CLU那里还带来另一种思想:异常说明。这样,就可以用编程的方式在方法的特征签名中,声明这个方法将会抛出异常。异常说明可能有两种意思。一个是“我的代码会产生这种异常,这由你来处理”。另一个是“我的代码忽略了这些异常,这由你来处理”。

值得注意的是,由于使用了模板,C++标准类库实现里根本没有使用异常说明。在Java中,对于泛型用于异常说明的方式存在着一些限制。

体系

Java把异常当作对象来处理,并定义一个基类java.lang.Throwable作为所有异常的超类。在Java API中已经定义了许多异常类,这些异常类分为两大类,错误Error和异常Exception。

Java异常体系结构呈树状,其层次结构图如图所示:

ex-class-strut.jpg

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

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

Java根据各个类库也定义了一些其他的异常,下面的表中列出了Java的非检查性异常。


异常描述
ArithmeticException当出现异常的运算条件时,抛出此异常。例如,一个整数"除以零"时,抛出此类的一个实例。
ArrayIndexOutOfBoundsException用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。
ArrayStoreException试图将错误类型的对象存储到一个对象数组时抛出的异常。
ClassCastException当试图将对象强制转换为不是实例的子类时,抛出该异常。
IllegalArgumentException抛出的异常表明向方法传递了一个不合法或不正确的参数。
IllegalMonitorStateException抛出的异常表明某一线程已经试图等待对象的监视器,或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
IllegalStateException在非法或不适当的时间调用方法时产生的信号。换句话说,即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。
IllegalThreadStateException线程没有处于请求操作所要求的适当状态时抛出的异常。
IndexOutOfBoundsException指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。
NegativeArraySizeException如果应用程序试图创建大小为负的数组,则抛出该异常。
NullPointerException当应用程序试图在需要对象的地方使用 null 时,抛出该异常
NumberFormatException当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。
SecurityException由安全管理器抛出的异常,指示存在安全侵犯。
StringIndexOutOfBoundsException此异常由 String 方法抛出,指示索引或者为负,或者超出字符串的大小。
UnsupportedOperationException当不支持请求的操作时,抛出该异常。

下面的表中列出了Java定义在java.lang包中的检查性异常类。

异常描述
ClassNotFoundException应用程序试图加载类时,找不到相应的类,抛出该异常。
CloneNotSupportedException当调用 Object 类中的 clone 方法克隆对象,但该对象的类无法实现 Cloneable 接口时,抛出该异常。
IllegalAccessException拒绝访问一个类的时候,抛出该异常。
InstantiationException当试图使用 Class 类中的 newInstance 方法创建一个类的实例,而指定的类对象因为是一个接口或是一个抽象类而无法实例化时,抛出该异常。
InterruptedException一个线程被另一个线程中断,抛出该异常。
NoSuchFieldException请求的变量不存在
NoSuchMethodException请求的方法不存在

异常方法

下面的列表是Throwable 类的主要方法:

序号方法及说明
1public String getMessage()
返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。
2public Throwable getCause()
返回一个Throwable 对象代表异常原因。
3public String toString()
使用getMessage()的结果返回类的串级名字。
4public void printStackTrace()
打印toString()结果和栈层次到System.err,即错误输出流。
5public StackTraceElement [] getStackTrace()
返回一个包含堆栈层次的数组。下标为0的元素代表栈顶,最后一个元素代表方法调用堆栈的栈底。
6public Throwable fillInStackTrace()
用当前的调用栈层次填充Throwable 对象栈层次,添加到栈层次任何先前信息中。

捕获异常

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

try/catch代码块中的代码称为保护代码,使用 try/catch的语法如下:

try{
   // 程序代码}catch(ExceptionName e1){
   //Catch 块}

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

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

实例

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

// 文件名 : ExcepTest.javaimport 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: 3Out of the block

多重捕获块

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

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

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

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

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

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

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

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

如此,直到异常被捕获或者通过所有的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关键字:

如果一个方法没有捕获一个检查性异常,那么该方法必须使用throws 关键字来声明。throws关键字放在方法签名的尾部。

也可以使用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{
    // 程序代码
 }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");
      }
   }}

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

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

注意下面事项:

  • catch不能独立于try存在。

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

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

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


声明自定义异常

在Java中你可以自定义异常。编写自己的异常类时需要记住下面的几点。

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

  • 如果希望写一个检查性异常类,则需要继承Exception类。

  • 如果你想写一个运行时异常类,那么需要继承RuntimeException 类。

可以像下面这样定义自己的异常类:

class MyException extends Exception{}

只继承Exception 类来创建的异常类是检查性异常类。

下面的InsufficientFundsException类是用户定义的异常类,它继承自Exception。

一个异常类和其它任何类一样,包含有变量和方法。

实例

// 文件名InsufficientFundsException.javaimport 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异常。

// 文件名称 CheckingAccount.javaimport 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程序示范了如何调用CheckingAccount类的deposit() 和withdraw()方法。

//文件名称 BankDemo.javapublic 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();
      }
    }}

编译上面三个文件,并运行程序BankDemo,得到结果如下所示:

Depositing $500...Withdrawing $100...Withdrawing $600...Sorry, but you are short $200.0InsufficientFundsException
        at CheckingAccount.withdraw(CheckingAccount.java:25)
        at BankDemo.main(BankDemo.java:13)

通用异常

在Java中定义了两种类型的异常和错误。

  • JVM(Java虚拟机)异常:由JVM抛出的异常或错误。例如:NullPointerException类,ArrayIndexOutOfBoundsException类,ClassCastException类。

  • 程序级异常:由程序或者API程序抛出的异常。例如IllegalArgumentException类,IllegalStateException类。



看到这里如果这篇文章真的帮到你了,不妨打赏一下哦!

以上就是红色火线JAVA加油站整理的关于Java异常以及处理原则的文章,
希望可以帮到你,如果你有不同的见解可以留言指正哦,避免让别的java小伙伴在走挫折路。
Tomcat集群配置学习篇-----分布式应用
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。

分享:

支付宝

微信