Java的异常处理

    Java的异常处理是通过5个关键字来实现的:try,catch,throw,throws,finally。Java的在线帮     助中对这几个关键字是这样解释的:  

   
      Throws: Lists the exceptions a method could throw. 

      Throws:列出一个方法可抛出的异常。 
      Throw: Transfers control of the method to the exception handler.  

      Throw:将方法的控制权传递给异常处理器。   
      Try:Opening exception-handling statement.

      Try:开启异常处理状态。     
      Catch:Captures the exception.  

      Catch:捕捉异常。   
      Finally:Runs its code before terminating the program.  

      Finally:结束此程序前运行本代码。

    throws语句   
      throws总是出现在一个函数头中,用来标明该成员函数可能抛出的各种异常。对大多数Exception       子类来说,Java 编译器会强迫你声明在一个成员函数中抛出的异常的类型。如果异类型是             Error或 RuntimeException,或它们的子类,这个规则不起作用, 因为这在程序的正常               部分中是不期待出现的。 如果你想明确地抛出一个RuntimeException,你必须用                     throws语句来声明它的类型。  
    throw语句   
      throw总是出现在函数体中,用来抛出一个异常。程序会在throw语句后立即终止,它后面的          语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹       配的catch子句的try块。

    try语句   
      try语句用大括号{}指定了一段代码,该段代码可能会抛弃一个或多个例外。

    catch语句   
      catch语句的参数类似于方法的声明,包括一个例外类型和一个例外对象。例外类型必              须为Throwable类的子类,它指明了catch语句所处理的例外类型,例外对象则由运行时系统在try       所指定的代码块中生成并被捕获,大括号中包含对象的处理,其中可以调用对象的方法。  

      catch语句可以有多个,分别处理不同类的例外。Java运行时系统从上到下分别对每                  个catch语句处理的例外类型进行检测,直到找到类型相匹配的catch语句为止。这里,类型          匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类,因此,          catch语句的排列顺序应该是从特殊到一般也可以用一个catch语句处理多个例外类型,这时          它的例外类型参数应该是这多个例外类型的父类,程序设计中要根据具体的情况来选择catch          语句的例外处理类型。   
   
    finally语句   
      try所限定的代码中,当抛弃一个例外时,其后的代码不会被执行。通过finally语句可以指定一       块代码。无论try所指定的程序块中抛弃或不抛弃例外,也无论catch语句的例外类型是否与          所抛弃的例外的类型一致,finally所指定的代码都要被执行,它提供了统一的出口。通常在          finally语句中可以进行资源的清除工作。如关闭打开的文件等。  

   

    Throws和Throw的区别:

      1.Throws是用来声明一个方法可能抛出的所有异常信息,跟在方法后面,将异常往上传,谁调用           我就交给谁处理;而throw则是指抛出的一个具体的异常类型,用在方法语句中。     

      2.throws可以单独使用,但throw不能;throws可以单独使用,然后再由处理异常的方法捕获 ,         throw要么和try-catch-finally语句配套使用,要么与throws配套使用。

示例:

class myException extends Exception //自定义Exception
{
  String msg;
  myException(int n)
  {
     msg="age can not be positive!";
   }
  public String toString()
  {
     return msg;
   }  
}

class Age{
  public void intage(int n) throws myException //throws用在方法后,抛出Exception
  {
    if(n<0||n>120)
    {
      myException e=new myException(n);
      throw e; //throw是一个转向语句,抛出对象实例,停止执行后面的代码
     }
    if(n>=0)
    {
      System.out.print("合理的年龄!");
     }
  }
   
  public static void main(String args[]) //主方法.................................
  {
    int a=-5;
    try 
    { 
      Age age = new Age();
      age.intage(a); //触发异常
      System.out.print("抛出异常后的代码"); //这段代码是不会被执行的,程序已经被转向
     } 
    catch (myException e) 
    {
      System.out.print(e.toString());
     }
    finally
    {//无论抛不抛异常,无论catch语句的异常类型是否与所抛出的例外的类型一致,finally所指定     //的代码都要被执行,它提供了统一的出口。
      System.out.print("进入finally!");
     }
   }
}

结果:age can not be positive! 进入finally!

示例:

void fun()throws IOException,SQLException  //
{ 
    ... 
 } 
//调用fun() 
try 
{ 
  fun(); 
 }
 catch(IOException e) 
{ 
  ...
 }
 catch(SQLException e) 
{ 
  ...
 }

 示例:

class Math{  
    public int div(int i,int j) throws Exception{   // 定义除法操作,如果有异常,则交给被                                                    //调用处处理  
        System.out.println("***** 计算开始 *****") ;  
        int temp = 0 ;  // 定义局部变量  
        try{  
            temp = i / j ;  // 计算,但是此处有可能出现异常  
        }catch(Exception e){  
            throw e ;  
        }finally{   // 不管是否有异常,都要执行统一出口  
            System.out.println("***** 计算结束 *****") ;  
        }  
        return temp ;  
    }  
};  
public class ThrowDemo02{  
    public static void main(String args[]){  
        Math m = new Math() ;  
        try{  
            System.out.println("除法操作:" + m.div(10,0)) ;  
        }catch(Exception e){  
            System.out.println("异常产生:" + e) ;  
        }  
    }  
};  
如果有异常输出:
除法操作:
***** 计算开始 *****
异常产生:...
***** 计算结束 *****