关于java:Java-异常处理

Java 异样解决

异样是程序中的一些谬误，但并不是所有的谬误都是异样，并且谬误有时候是能够防止的。

比如说，你的代码少了一个分号，那么运行进去后果是提醒是谬误 java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异样。

异样产生的起因有很多，通常蕴含以下几大类：

• 用户输出了非法数据。
• 要关上的文件不存在。
• 网络通信时连贯中断，或者JVM内存溢出。

这些异样有的是因为用户谬误引起，有的是程序谬误引起的，还有其它一些是因为物理谬误引起的。-

要了解Java异样解决是如何工作的，你须要把握以下三种类型的异样：

• 查看性异样：最具代表的查看性异样是用户谬误或问题引起的异样，这是程序员无奈预感的。例如要关上一个不存在文件时，一个异样就产生了，这些异样在编译时不能被简略地疏忽。
• 运行时异样： 运行时异样是可能被程序员防止的异样。与查看性异样相同，运行时异样能够在编译时被疏忽。
• 谬误： 谬误不是异样，而是脱离程序员管制的问题。谬误在代码中通常被疏忽。例如，当栈溢出时，一个谬误就产生了，它们在编译也查看不到的。

Exception 类的档次

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

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

Java 程序通常不捕捉谬误。谬误个别产生在重大故障时，它们在Java程序处理的领域之外。

Error 用来批示运行时环境产生的谬误。

例如，JVM 内存溢出。个别地，程序不会从谬误中复原。

异样类有两个次要的子类：IOException 类和 RuntimeException 类。

在 Java 内置类中(接下来会阐明)，有大部分罕用查看性和非查看性异样。

Java 内置异样类

Java 语言定义了一些异样类在 java.lang 规范包中。

规范运行时异样类的子类是最常见的异样类。因为 java.lang 包是默认加载到所有的 Java 程序的，所以大部分从运行时异样类继承而来的异样都能够间接应用。

Java 依据各个类库也定义了一些其余的异样，上面的表中列出了 Java 的非查看性异样。

捕捉异样

应用 try 和 catch 关键字能够捕捉异样。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[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(异样类型2 异样的变量名2){
  // 程序代码
}

下面的代码段蕴含了 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;
}

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: 3
First element value: 6
The 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。

一个异样类和其它任何类一样，蕴含有变量和办法。

通用异样

在Java中定义了两种类型的异样和谬误。

• JVM(Java虚拟机) 异样：由 JVM 抛出的异样或谬误。例如：NullPointerException 类，ArrayIndexOutOfBoundsException 类，ClassCastException 类。
• 程序级异样：由程序或者API程序抛出的异样。例如 IllegalArgumentException 类，IllegalStateException 类。