java中的异常详解

异常：程序在运行过程中的一些特殊情况，例如：内存不够用，文件找不到，对象是Null，数组下标越界。当产生这些特殊情况的时候，可能会造成程序不能正常运行。

异常处理：让程序在发生异常的时候能够正常执行。

2、异常分类

检查性异常，必须处理，如果不处理，编译不能通过。

非检查性异常，可以不处理，但是一旦发生，程序就不能继续运行。

3、对于非检查性异常

虽然编译的时候不会报错，能够运行。但是运行的时候，如果发生错误，后果很严重。所以还是要处理。可以通过增加代码来解决。

例子：对于NullPointerException，在调用方法之前可以检查这个对象是否为null

if(date!=null){

date.getTime();

}

例子：a/b（b为0产生异常），代码中可以检查b是否为0

if(b!=0)

a/b;

else

// 抛出异常！

也可以采用try-catch进行处理。

4、try...catch对异常处理

准备工作：在进行异常处理之前，必须清楚可能会发生哪些异常，异常与要调用的方法有关，通常在方法的定义中通过throws声明可能发生的异常。

把可能产生异常的代码放在try语句中；

针对每种可能出现的异常，编写一个catch，catch中写出异常类型；

在catch对应的代码中编写对异常进行处理的代码，当异常产生并与当前异常类型匹配，将执行catch中的代码。

基本结构：

try{

// 可能产生异常的代码

}catch(异常类型 异常对象){

// 异常产生时候的处理代码

}

注意：

每种类型的异常都必须有对应的catch，所有的异常都应该处理。

可以使用某个父类异常匹配多个子类异常。例如：catch(Exception e){}

如果异常类型之间有继承关系，子类一定要在前面。

如果希望某个变量在try和catch中都可以使用，则应该把变量的定义放在try语句之前。

例子：

package ch11;

import java.io.IOException;

public class Test {

public static void main(String[] args) {

String str1 = new String("111a");

str1 = "22";

String str2 = "456";

// 把可能产生异常的代码写在try语句中

try{

int x = Integer.parseInt(str1);

int y = Integer.parseInt(str2);

System.in.read();

// 当产生异常的时候，try语句中异常代码之后的代码不会执行

System.out.println(x+y);

// return ;

}catch(NumberFormatException e){ // 根据可能会出现的异常，写Catch，每种

类型的异常可以写一个Catch，Catch可以有多个，可以用父类异常匹配多个子类异常

// 如果多个Catch中的异常类型有继承关系，子类要写在前面

// 如果匹配上某种类型的异常，将执行catch中的代码

System.out.println(e.getMessage());

System.out.println("---------------------------------");

System.out.println(e.toString());

System.out.println("---------------------------------");

e.printStackTrace();

}catch(IOException e){

}

// 如果try语句没有给出catch，则必须给出finally，不管是否产生异常，

finally中代码都将执行，如果给出catch，也可以给出finally

finally{

System.out.println("程序继续运行！");

}

//System.out.println(new Test().check());

}

public boolean check() throws IOException{

String str = "adasf";

System.in.read();

int a = Integer.parseInt(str);

return true;

}

}

5、获取异常信息

当产生异常的时候，会匹配上某个catch，系统会把异常对象赋值给catch中的变量，在catch代码块中可以访问异常信息，通过如下方法：

getMessage() 得到异常的最简单的描述

toString() 得到比较详细的异常信息

printStackTrace() 会把异常信息输出在默认的输出设备中。

例如：

try{

// 可能产生异常的代码

}catch(Exception e){

System.out.println(e.toString());

System.out.println(e.getMessage());

e.printStackTrace();

}

6、finally

如果希望某些代码一定执行，不管是否发生异常，可以把这些代码放在finally中，与try一起使用，

基本结构

try{

// 代码块

}catch(异常1 e1){

}catch(异常2 e2){

}finally{

// 一定要执行的代码

}

即使在try或者catch中有return语句，finally也一定会执行，在return之前执行。

7、异常的抛出

异常通常在方法中抛出，通过throw关键字，例如：throw new MyException("sds");

如果方法中有抛出异常的代码，则方法的声明中应该使用throws声明异常的类型，例如：

public void print() throws MyException{

...

throw new MyException("sdfs");

...

}

8、创建自己的异常类

继承Exception，实现构造方法即可。

package ch11;

public class MyException extends Exception {

public MyException(){

}

public MyException(String args){

super(args);

}

}

9、例子

package ch11;

public class Exercise {

public static void main(String[] args) {

int a[] = {1,3,4};

boolean hasException = false;

try{

a[3] = 4;

// hasException = false;

}catch(Exception e){

System.out.println("数组越界！");

hasException = true;

}finally{

if(hasException){

System.out.println("程序异常运行结束！");

}else{

System.out.println("程序正常运行结束！");

}

}

Exercise e = new Exercise();

try{

e.setAge(1000);

}catch(MyException ee){

System.out.println(ee.getMessage());

}

}

public void setAge(int age) throws MyException{

if(age<0 || age>120){

throw new MyException(age+"不是一个合理的年龄值！");

}

}

}

首先Java的异常是面向对象的。一个Java的Exception是一个描述异常情况的对象。当出现异常情况时，一个Exception对象就产生了，并放到异常的成员函数里。

Java的异常处理是通过5个关键词来实现的：try,catch,throw,throws和finally。

1.异常处理：

在Java语言的错误处理结构由try，catch，finally三个块组成。其中try块存放将可能发生异常的Java语言，并管理相关的异常指针；catch块紧跟在try块后面，用来激发被捕获的异常；finally块包含清除程序没有释放的资源，句柄等。不管try块中的代码如何退出，都将执行finally块。

2.抛出异常：

Java语言可以不在方法中直接捕获，而用throw语句将异常抛给上层的调用者。Throw语句就是来明确地抛出一个异常；首先你必需得到一个Throwable的实例句柄，通过参数传到catch中，或者采用new操作符来创建一个。

例如：public void execute（String str,int index） throws WhcaException{

try{

//可能产生异常的代码；

}catch（Exception e）{

throw new WhcaException（“JB: M:”+e.getMessage）；

}

}

最后谈谈使用"异常机制"的需要注意的几点

1.一个方法中可能会产生多种不同的异常，你可以设置多个"异常"抛出点来解决这个问题。

2."异常"对象从产生点产生后，到被捕捉后终止生命的全过程中，实际上是一个传值过程，所以你可以根据需要，来合理的控制检测到"异常"的粒度。

3."异常机制"中还有一种特殊情况――RuntimeException"异常类"，这个"异常类"和它的所有子类都有一个特性，就是"异常"对象一产生就被Java虚拟机直接处理掉，即在方法中出现throw子句的地方便被虚拟机捕捉了。因此凡是抛出这种"运行时异常"的方法在被引用时，不需要有try…catch语句来处理"异常"。

4.捕获了异常，就要对它进行适当的处理。调用printStackTrace对调试程序有帮助，但没有真正的处理异常！

printStackTrace（）方法只能分析程序运行情况，在JDK1.4中提供了StackTraceElement类来获取程序的运行情况！例：

import javax.swing.*;

public class StackTraceTest

{

public static int factorial（int n） {

System.out.print（"迭代： （"+n+"）："）；

Throwable t=new Throwable（）；

StackTraceElement[] frames=t.getStackTrace（）；

for（int i=0;i

System.out.println（frames[i]）；

int r;

if（n<=1） r=1;

else r=n*factorial（n-1）；

System.out.println（"return " +r）；

return r;

}

public static void main（String[] args） {

String input=JOptionPane.showInputDialog（"Enter n:"）；

int n=Integer.parseInt（input）；

factorial（n）；

System.exit（0）；

}

}