java中的异常详解

1、什么是异常处理

异常：程序在运行过程中的一些特殊情况，例如：内存不够用，文件找不到，对象是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(Exceptione){}

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

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

 

例子：

package ch11;

 

import java.io.IOException;

 

public class Test {

 

      public static voidmain(String[] args) {

            String str1 = newString("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(NumberFormatExceptione){ // 根据可能会出现的异常，写Catch，每种

 

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

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

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

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

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

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

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

                 e.printStackTrace();

            }catch(IOExceptione){

                

            }

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

 

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

            finally{

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

            }

           

            //System.out.println(newTest().check());

      }

     

      public boolean check() throwsIOException{

            String str ="adasf";

           System.in.read();

            int a =Integer.parseInt(str);

 

            returntrue;

      }

 

}

 

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 newMyException("sds");

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

public void print() throwsMyException{

  ...

     throw newMyException("sdfs");

  ...

}

 

8、创建自己的异常类

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

package ch11;

 

public class MyException extends Exception{

      publicMyException(){

           

      }

      public MyException(Stringargs){

           super(args);

      }

}

 

9、例子

package ch11;

 

public class Exercise {

 

      public static voidmain(String[] args) {

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

            boolean hasException =false;

            try{

                  a[3] =4;

//               hasException = false;

            }catch(Exceptione){

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

                 hasException = true;

            }finally{

                 if(hasException){

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

                 }else{

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

                 }

            }

           

            Exercise e = newExercise();

            try{

                 e.setAge(1000);

            }catch(MyExceptionee){

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

            }

      }

     

      public void setAge(int age)throws MyException{

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

                  throw newMyException(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） throwsWhcaException{

   try{

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

   }catch（Exception e）{

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

   }

   }

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

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

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

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

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

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

    importjavax.swing.*;

    publicclass StackTraceTest

   {

    publicstatic int factorial（int n） {

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

   Throwable t=new Throwable（）；

   StackTraceElement[] frames=t.getStackTrace（）；

    for（inti=0;i

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

    intr;

   if（n<=1） r=1;

    elser=n*factorial（n-1）；

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

    returnr;

   }

    publicstatic void main（String[] args） {

    Stringinput=JOptionPane.showInputDialog（"Enter n:"）；

    intn=Integer.parseInt（input）；

   factorial（n）；

   System.exit（0）；

   }

   }