关于java:Java-异常处理

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

异样	形容
ArithmeticException	当出现异常的运算条件时，抛出此异样。例如，一个整数 ” 除以零 ” 时，抛出此类的一个实例。
IllegalArgumentException	抛出的异样表明向办法传递了一个不非法或不正确的参数
IllegalStateException	在非法或不适当的工夫调用办法时产生的信号。换句话说，即 Java 环境或 Java 应用程序没有处于申请操作所要求的适当状态下。
IndexOutOfBoundsException	批示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。
NullPointerException	当应用程序试图在须要对象的中央应用 `null` 时，抛出该异样
NumberFormatException	当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格局时，抛出该异样。
SecurityException	由平安管理器抛出的异样，批示存在平安进犯。
ClassNotFoundException	应用程序试图加载类时，找不到相应的类，抛出该异样。
NoSuchFieldException	申请的变量不存在
NoSuchMethodException	申请的办法不存在

应用 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 关键字来申明。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 关键字用来创立在 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 类。

关于java:Java-异常处理

Java 异样解决

Exception 类的档次

Java 内置异样类

捕捉异样

实例

多重捕捉块

实例

throws/throw 关键字：

finally 关键字

实例

申明自定义异样

通用异样