Java Exception

package myExample.testException;

public class TestException {

public TestException() {

}

boolean testEx() throws Exception{

boolean ret = true;

try{

ret = testEx1();

}catch (Exception e){

System.out.println("testEx, catch exception");

ret = false;

throw e;

}finally{

System.out.println("testEx, finally; return value="+ret);

return ret;

}

}



boolean testEx1() throws Exception{

boolean ret = true;

try{

ret = testEx2();

if (!ret){

return false;

}

System.out.println("testEx1, at the end of try");

return ret;

}catch (Exception e){

System.out.println("testEx1, catch exception");

ret = false;

throw e;

}

finally{

System.out.println("testEx1, finally; return value="+ret);

return ret;

}

}



boolean testEx2() throws Exception{

boolean ret = true;

try{

int b=12;

int c;

for (int i=2;i>=-2;i--){

c=b/i;

System.out.println("i="+i);

}

return true;

}catch (Exception e){

System.out.println("testEx2, catch exception");

ret = false;

throw e;

}

finally{

System.out.println("testEx2, finally; return value="+ret);

return ret;

}

}



public static void main(String[] args) {

TestException testException1 = new TestException();

try{

testException1.testEx();

}catch(Exception e){

e.printStackTrace();

}

}

}


i=2



i=1



testEx2, catch exception



testEx2, finally; return value=false



testEx1, finally; return value=false



testEx, finally; return value=false

Java通过面向对象的方法来处理异常。在一个方法的运行过程中，如果发生了异常，则这个方法生成代表该异常的一个对象，并把它交给运行时系统，运行时系统寻找相应的代码来处理这一异常。我们把生成异常对象并把它提交给运行时系统的过程称为抛出(throw)一个异常。运行时系统在方法的调用栈中查找，从生成异常的方法开始进行回朔，直到找到包含相应异常处理的方法为止，这一个过程称为捕获(catch)一个异常。

用面向对象的方法处理异常，就必须建立类的层次。类 Throwable位于这一类层次的最顶层，只有它的后代才可以做为一个异常被抛出。类Throwable有两个直接子类：Error和Exception。
Error类对象（如动态连接错误等），由Java虚拟机生成并抛弃（通常，Java程序不对这类异常进行处理）；
Exception类对象是Java程序处理或抛弃的对象。它有各种不同的子类分别对应于不同类型的异常。其中类RuntimeException代表运行时由Java虚拟机生成的异常，如算术运算异常ArithmeticException(由除0错等导致)、数组越界异常ArrayIndexOutOfBoundsException等；其它则为非运行时异常，如输入输出异常IOException等。Java编译器要求Java程序必须捕获或声明所有的非运行时异常，但对运行时异常可以不做处理。

Java的异常处理是通过5个关键字来实现的：try，catch，throw，throws，finally。
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语句用大括号{}指定了一段代码，该段代码可能会抛出一个或多个异常。

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

catch语句可以有多个，分别处理不同类的异常。Java运行时系统从上到下分别对每个catch语句处理的异常类型进行检测，直到找到类型相匹配的catch语句为止。这里，类型匹配指catch所处理的异常类型与生成的异常对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序应该是从特殊到一般。

也可以用一个catch语句处理多个异常类型，这时它的异常类型参数应该是这多个异常类型的父类，程序设计中要根据具体的情况来选择catch语句的异常处理类型。
 
无论try所指定的程序块中抛出或不抛出异常，也无论catch语句的异常类型是否与所抛出的异常的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。

throws和throw的区别

这两者虽然看起来只有一个s的区别，但是作用完全不一样。
                                                                                   
/////java处理异常方式///////////////////////////////

     在java代码中如果发生异常的话，jvm会抛出异常对象，导致程序代码中断，这个时候jvm在做的操作就是：创建异常对象，然后抛出，比如：



int i= 1；
int j = 0；
int res = 0；
res = i/j；//除0错误
System.out.println(res);


这5句代码运行到第四句会中断，因为jvm抛出了异常

////throw的作用/////////////////////////////////////////
手动抛出异常

但是有时候有些错误在jvm看来不是错误，比如说

int age = 0;
age = -100;
System.out.println(age);


    很正常的整形变量赋值，但是在我们眼中看来就不正常，谁的年龄会是负的呢。 所以我们需要自己手动引发异常，这就是throw的作用。

int age = 0;
age = -100;
if(age<0)
{
   Exception e = new Exception("throw exception");//创建异常对象
   throw e;//抛出异常
}
System.out.println(age);


////throws的作用///////////////////////////////////
声明方法可能回避的异常

   有异常被抛出了，就要做处理，所以java中有try-catch。可是有时候一个方法中产生了异常，但是不知道该怎么处理它，那么就放着不管，当有异常抛出时会中断该方法，而异常被抛到这个方法的调用者那里。这个有点像下属处理不了的问题就交到上司手里一样，这种情况称为回避异常。

   但是这使得调用这个方法就有了危险，因为谁也不知道这个方法什么时候会丢一个什么样的异常给调用者，所以在定义方法时，就需要在方法头部分使用throws来声明这个方法可能回避的异常。

void fun()throws IOException,SQLException
{

}


这表示 fun方法可能会丢两个异常出来，那么在调用fun的时候就会做好准备，比如可以这样

try{
   fun();
}catch(IOException e) { }
catch(SQLException e) { }