最近一直throw和throw new …… 获取头部罢工，要彻底生气清楚这件事，他对这个思想精华收集了很多网友。这里摘录．

throws全部异常信息
throw则是指抛出的一个详细的异常类型。
通常在一个方法（类）的声明处通过throws声明方法（类）可能抛出的异常信息。而在方法（类）内部通过throw声明一个详细的异常信息。
throws通常不用显示的捕获异常，可由系统自己主动将全部捕获的异常信息抛给上级方法；
throw则须要用户自己捕获相关的异常，而后在对其进行相关包装，最后再将包装后的异常信息抛出。
对异常处理方式不同.throws对异常不处理,谁调用谁处理,throws的Exception的取值范围要大于方法内部异常的最大范围,而cathch的范围又要大于throws的Exception的范围;throw 主动抛出自己定义异常类对象. throws抛出的是类,throw抛出的是对象.

在方法定义中表示的是陈述语气，第三人称单数，throw 显然要加s。

(throws 一般用作方法定义的子句)
在函数体中要用throw，实际上是祈使句+强调，等价于DO throw ....,do +动词原形

throw 用于引发异常。可引发提前定义异常和自己定义异常。

I)异常中“throws”和“throw”的差别:

throw 是个“动词”。紧接在try语句块之后。

而throws 是“名词” ，用在函数方法名后 function A () throws Exception e {}
throw用在程序中明白表示这里抛出一个异常。throws用在方法声明的地方。表示这种方法可能会抛出某异常。

throw用来抛出实际的异常, 后面要跟一个异常对象(实例), 是一个实际的语句
throws是用来声明的, 加在方法声明的后面, 后面跟一个异常类的名字, 表示一般性动作而不是特指某一个动作.

使用throws是来说明，当前的函数会抛出一个异常。

在一般的情况下，你调用的一些函数会抛出一些异常。可是你又不想在当前的context中去处理它，就能够声明该函数会抛出该异常。这样你就不用去try-catch它了。当出现该异常,该函数会抛出此异常，让上一层的函数去处理。throws也称异常规范
public static h() throws
{
     try
     {
         a.g();
     }
     catch(Exception e)
     {
         throw e;
     }
}
由于你没有对这个异常处理。而是简单的抛出了。
而单纯的声明
public static h() throws
{
     a.g();
}
也会抛出这个异常
II)try catch /throws /throw

throws假设发生了相应的错误后。下边的的确不会被运行；
try catch的理解应该辩证点看：假设catch后没有再次throw出去，那会继续运行。要想不运行必须throw处理
throws   抛出异常。解决不了再向上,直道碰到能解决这个异常的处理程序，就好像你的上司让你运行一项任务，中途你遇到问题不知道怎样解决。你把问题返还给你的上司。觉得既然是T分配的任务就该知道怎样解决问题，你的上司无法解决相同把它送给经理解决。依次向上。直到有人能解决问题为止（不想自己另外写代码处理异常时很实用）
try catch    则是考虑到try包括这段代码可能会遇到这样的异常。直接用catch捕获处理。catch包括的代码为处理代码

throws 仅仅是把一个异常抛出去了，假设你的上层代码有处理方式，就由上层代码来处理这个异常。
而try/catch对是清楚的知道该操作可能出现什么异常，同一时候在catch块中应该有处理的方法。
并且另一种方式就是try/catch/finaly的方式。

Throws是把异常返回给调用者，由调用者处理，调用者还是要try/catch，跑不掉的
catch中就一个简单的SYSTEM.OUT.PRINTLN（…………）；还有。连接数据库时会连接不上，你也不知道是驱动问题、电脑问题还是网络问题，发给用户。用户也看不懂，所以统统throws给catch，提示请与管理员联系。

。。

。。

。这就简单多了

throws 写在方法签名后。
throw 写在方法体内，能够写在if()....
也能够catch住一个exception后立马又把他throw 出去。什么处理也不做，还能够catch住后throw new 一个你自定义的exception ....

throws 就是把异常抛出，可是在以后要不有个catch接受，要不就抛给主函数.就是逐级往上一级抛。直到有一个接受他的

Throws抛出异常交给调用该方法的方法 处理，即：
public class Test{
    public static void main(String[] args){
        Test2 test2 = new Test2();
        try{
           System.out.println("invoke the method begin!");
           test2.method();
           System.out.println("invoke the method end!");
        }catch(Exception e){
           System.out.println("catch Exception!");
        }
    }
}

class Test2{
    public void method() throws Exception{
        System.out.println("method begin!");
        int a = 10;
        int b = 0;
        int c = a/b;
        System.out.println("method end!");
    }
}

非常明显，答案出来了：
invoke the method begin!
method begin!
catch Exception!

finally语句是任选的。try语句后至少要有一个catch或一个finally,finally语句为异常处理提供一个统一的出口，不论try代码块是否发生了异常事件，finally块中的语句都会被运行
在覆盖的方法中声明异常
在子类中。假设要覆盖父类的一个方法，或父类中的方法声明了throws异常，则子类的方法也能够抛出异常。但切记子类方法抛出的异常仅仅能是父类方法抛出的异常的同类或子类。
如：
import java.io.*;
class A {
public void methodA()throws IOException{
.....
}
}
class B1 extends A {
public void methodA()throws FileNotFoundException{
....}
}
class B2 extends A {
public void methodA()throws Exception{//Error
....}
}

public void method() throws Exception {
try {
      详细程序
} catch(Exception ex) {

}
}
假设详细程序出错的话。将处理以下程序体中catch的地方,这个时候throws Exception 事实上是没有意义的。
public void method() throws Exception {
try {
      详细程序
} catch(FileNotFoundException ex) {

}
}

假设详细程序出错的话，且是FileNotFoundException 的情况下，将处理以下程序体中catch的地方处理。
这个时候FileNotFoundException 以外的Exception 将通过 throws Exception ，throw到上一层。

throw写在方法体内, throws写在方法名的后面
throwkeyword的格式：throw new ArithmeticException(); 抛出一个异常。这些异常能够使unchecked exception(也就是RuntimeException),也能够是checked execption. throw必须有一个捕获该异常的try/catch语句
throwskeyword的格式
private void arrayMethod(int[] arr)
           throws ArrayIndexOutOfBoundsException,
                  ArithmeticException {
     //   Body
}
throws子句列出了方法可能抛出的异常类型。除了Error和RuntimeException异常,方法中可能抛出的异常必须在throws列表中声明,否则会有编译错误。

例如：如果方法可能引发IllegalAccessException(属于checked execption)你必须throws语句列表。

系统异常被抛出默认,要显示抛出一个自定义异常

其他的都只是一个图书馆的方法throw 无治疗,所以，表面上你看不到throw还catch异常