异常机制及throw与throws的区别

Java的异常处理

Java的异常处理是通过5个关键字来实现的：try，catch，throw，

throws，finally。JB的在线帮助中对这几个关键字是这样解释的：  
   
  Throws: Lists the exceptions a method could throw.  
   
  Throw: Transfers control of the method to the exception handler.  
   
  Try： Opening exception-handling statement.  
   
  Catch： Captures the exception.  
   
  Finally： Runs its code before terminating the program.  
 try语句　 

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

例外。  
   
  catch语句　 

 
  catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对

象。例外类型必须为Throwable类的子类，它指明了catch语句所处理的例

外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕

获，大括号中包含对象的处理，其中可以调用对象的方法。  
   
 

catch语句可以有多个，分别处理不同类的例外。Java运行时系统从上到

下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配

的 catch语句为止。这里，类型匹配指catch所处理的例外类型与生成的

例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序

应该是从特殊到一般。  
   
   
   
  也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应

该是这多个例外类型的父类，程序设计中要根据具体的情况来选择catch

语句的例外处理类型。　  
   
  finally语句　  
  try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。通

过finally语句可以指定一块代码。无论try所指定的程序块中抛弃或不抛

弃例外，也无论catch语句的例外类型是否与所抛弃的例外的类型一致，

finally所指定的代码都要被执行，它提供了统一的出口。通常在finally

语句中可以进行资源的清除工作。如关闭打开的文件等。  
   
  throws语句　  
  throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种

异常。对大多数Exception子类来说，Java 编译器会强迫你声明在一个成

员函数中抛出的异常的类型。如果异常的类型是Error或

RuntimeException， 或它们的子类，这个规则不起作用， 因为这在程序

的正常部分中是不期待出现的。 如果你想明确地抛出一个

RuntimeException，你必须用throws语句来声明它的类型。  
   
  throw语句　  
  throw总是出现在函数体中，用来抛出一个异常。程序会在throw语句后

立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能

在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。



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

class Age{
  public void intage(int n) throws myException{//
  if(n<0||n>120){
  myException e=new myException(n);
  throw e; //是一个转向语句，抛出对象实例，停止执行后面的代码
  }
  if(n>=0){
  System.out.print("合理的年龄!");
  }
  }
   
public static void main(String args[]) {
  int a=-5;
  try { //try catch 必需有
  Age age = new Age();
  age.intage(a);//触发异常
  System.out.print("抛出异常后的代码") ;//这段代码是不会被执行

的，程序已经被转向
  } catch (myException ex) {
  System.out.print(ex.toString());
  }
  finally{//无论抛不抛异常，无论catch语句的异常类型是否与所抛出

的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的

出口。
  System.out.print("进入finally！ ");
  }
  }
}

结果：年龄非法！ 进入finally！ 

又如：
void fun()throws IOException,SQLException 
{ 
... 
} 
这表示 fun方法可能会丢两个异常出来，那么在调用fun的时候就会做好

准备，比如可以这样 
try 
{ 
fun(); 
}catch(IOException e) 
{ 
}catch(SQLException e) 
{ 

}

区别一：

  throw 是语句抛出一个异常；throws 是方法抛出一个异常；

  throw语法：throw <异常对象>

  在方法声明中，添加throws子句表示该方法将抛出异常。

  throws语法：[<修饰符>]<返回值类型><方法名>（[<参数列表>]）[throws<异常类>]

  其中：异常类可以声明多个，用逗号分割。

区别二：

  throws可以单独使用，但throw不能；

区别三：

  throw要么和try-catch-finally语句配套使用，要么与throws配套使

用。但throws可以单独使 用，然后再由处理异常的方法捕获。

throws E1,E2,E3 只是告诉程序这个方法可能会抛出这些个异常，方法的

调用者可能要处理这些异常。而这些异常E1，E2，E3可能是该函数体产生

的。

而throw是明确之处这个地方要抛出这个异常。

void doA() throws Exception1, Exception3 {
  try {
  ……
  } catch(Exception1 e) {
  throw e;
  } catch(Exception2 e) {
  System.out.println("出错了");
  }
  if (a != b)
  throw new Exception3("自定义异常");
}

代码块……中可能产生异常Exception1、Exception2和Exception3。

如果产生Exception1异常，则捕捉了之后抛出由该方法的调用者去做处

理；

如果产生Exception2异常，则该方法自己做了处理(打印出了说出错了)，

所以该方法就不会再向外抛出Exception2异常了，void doA() throws

Exception1,,Excpetion3里面的Exception2也就不用写了；

而Exception3异常是该方法的某段逻辑出错，程序员自己作了处理在该段

逻辑错误的情况下抛出异常Exception3，则调用者也需要处理。


throw语句用在方法体内,表示抛出异常,由方法体内的语句处理 

throws语句用在方法声明后面,表示再抛出异常,由调用这个方法的上一级

方法中的语句来处理

throws主要是声明这个方法会抛出这种类型的异常，使其他地方调用它时

知道要捕获这个异常。

throw是具体向外抛异常的动作，所以它是抛出一个异常实例。

throws说明你有哪个可能，倾向 

throw的话，那就是你把那个倾向变成真实的了

同时：
1）throws出现在方法函数头；而throw出现在函数体； 
2）throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常； 
3）两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。

参考网址：

http://www.cnblogs.com/carbs/archive/2012/06/26/2563931.html

http://wenku.baidu.com/view/486ab58171fe910ef12df803.html

http://wenku.baidu.com/view/9acf8fee0975f46527d3e158.html