由于java是c\c++ 发展而来的,  首先我们先看看c语言里的错误.

 

        我们实现1个程序的过程包括,  代码编写, 编译代码成为程序,  执行程序.

.

 

        其中大部分常见的语法错误都会被编译代码这样部过滤掉.   但是即使通过了编译. 执行程序这一步可能还是会有错误.

 

        原因很多, 例如常见的除数为0,    内存溢出(数组的index超出界限), 或者内存被其他程序修改等.

 

        最简单的例子:

       上面的例子编译时是无错的,  但是一旦执行就会提示吐核错误了. 

 

       c语言里对这种执行时出现的错误是无能为力的,  一旦出错就会整个程序崩溃, 就不会在继续执行下面的代码.

 

       而且很多时候出错信息很少, 让你无法判断出错的原因和地方, 只能一步步小心debug...

 

       所以很多用c写的程序有时会出现非法关闭的现象.

 

       解决方法只能是在代码里对可能出错的地方添加if 判断.

 

       例如f()函数里可以对b进行判断, 如果是0就不执行.

 

 

1.2 java里运行时出现的错误

      运行时一样会出错, 下面是出错信息:

 

          但是可以见到, java告诉你出错的类型: 运算错误(ArithmeticExcetion), 出错信息和出错的类与文件行数输出, 方便你调试.  jvm虚拟机是会对错误作出一定的处理的.

  

          所以可以简单地将java里的异常理解成java运行时出现的错误,  异常机制就是对这种错误进行处理的机制.

 

 

1.3 java异常的定义

        实际上, 当java程序执行时出现错误时, jvm会把执行时出错的信息(例如出错原因, 类型, 位置) 收集,然后打包成为1个对象(object),  程序员可以对这种对象进行处理. 这种对象就是所谓的异常.

 

        可能出现的异常的代码并不是肯定会出现异常, 取决于执行环境和数据.!

 

二, java里的异常的分类.

                                                     xxxxxx             ArithmeticException

 

 

 

上图的所有对象都是类.     

 

Throwable 代表是可抛出的.

Error            代表的是严重错误,  这种错误程序员无法进行处理, 例如操作系统崩溃, jvm出错, 动态链接库失败等.  Error并不是异常, 不是本文的重点.

 

Exception    代表的就是异常了.  它下面很多派生类,   其中它的派生类也分两种, 一种是RuntimeException(运行时异常), 其他的都是非运行时异常

 

RuntimeException    包括除数为0, 数组下标超界等. 运行时异常的派生类有很多, 其产生频率较高.  它的派生类可以由程序处理或者抛给(throw) 给jvm处理. 例如上面的例子就是抛给了jvm处理, jvm把程序中断执行, 并把错误信息输出到终端上.

 

非RuntimeExcption   这种异常属于Excepion的派生类(上面红色的xxx), 但是不是RuntimeException的派生类,  这种异常必须由程序员手动处理,否则不通过编译.

 

ArithmeticExcpetion   算术异常, 它是RuntimeException的派生类, 所以程序员不手动处理也通过编译, 只不过出错时会被jvm处理.

 

 

 

 

三, java里对异常的处理

3.1 程序猿对有可能出现的异常使用try catch处理.

在f()函数中对可能出现的异常的代码进行try catch处理后,  程序会执行catch里的代码. 而且不会中断整个程序, 继续执行try catch后面的代码.

 

程序执行输出:

 

注意最终也执行了g()函数中的最后一条语句, 输出了i的值.

 

也就是说try catch处理后并不会终止程序, 令程序即使出现了错误,  也可以对错误进行一定的处理后继续执行. 这就是java异常机制比c语言安全的地方.

 

下面会详细讲解 try catch.

 

注:

 

 

 

3.2 函数里并不处理异常, 使用throw or throws 关键字 把可能出现的异常抛给调用该函数的上级函数处理.

try{

...

}

4.1 try catch finally的执行路线.

下面用个例子来说明:

4.1.1 当try里面的f()抛出了IOException

当f()抛出了异常, 那么ff()就不会执行了.  程序会尝试捕捉异常.

首先捕捉ArithmeticException,  捕捉失败.

接下来捕捉IOException, 捕捉成功, 执行gg();

一旦捕捉到一个异常, 不会再尝试捕捉其他异常, 直接执行finally里的h();

执行后面的函数k().

也就是说路线是:

f()  ->  gg()  -> h() -> k()


有2点要注意的.

1. f()函数极有可能未完整执行, 因为它抛出了异常, 抛出异常的语句执行失败, 之后的语句放弃执行.

2. try{} 里面, f()之后的语句, 例如ff()放弃执行.

4.1.2 没有任何异常抛出

这种情况很简单, 就是try{}里面的代码被完整执行, 因为没有抛出任何异常, 就不会尝试执行catch里的部分, 直接到finally部分了.

路线是:
f()  ->  ff()  -> h() -> k()

 

 

4.2 如何确定要捕捉的异常名字.

 

也许有人会问, 我们怎么知道到底会抛出什么异常?

下面有3个解决方案.

1.看代码凭经验, 例如看到1段除法的代码, 则有可能抛出算术异常.

2.在catch的括号里写上Exception e,  毕竟Exception 是所有其他异常的超类, 这里涉及多态的知识,  至于什么是多态可以看看本人的另一篇文章.

3. 观察被调用函数的函数定义, 如果有throws后缀, 则可以尝试捕捉throws 后缀抛出的异常

 

4.3 为什么需要finally

 

包括我在内很多人会觉得finally语句简直多勾余, 既然是否捕捉到异常都会执行, 上面那个例子里的h()为什么不跟下面的k() 写在一起呢.

上面的例子的确看不出区别.

 

但下面两种情况下就体现了finally独特的重要性.

 

4.3.1 抛出了1个异常, 但是没有被任何catch子句捕捉成功.

 

例如try里面抛出了1个A异常,  但是只有后面只有捕捉B异常, 和C异常的子句. 

这种情况下, 程序直接执行finally{}里的子句,  然后中断当前函数, 把异常抛给上一级函数, 所以当前函数finally后面的语句不会被执行.

例子:

 

我所说的情况, 就在上面例子里的g()函数,  g()函数里尝试捕捉两个异常, 但是抛出了第3个异常(ArithmeticException 算术异常).

 

所以这个异常会中断g()的执行, 因为没有被捕捉到, 然后抛给调用g()的 h()函数处理,  而在h()捕捉到了, 所以h()函数是能完整执行的.

也就是说g()里的

 

 

执行失败

而h()里的

 

执行成功

 

但是无论如何, g()里的finally{}部分还是被执行了

执行结果如下:

 

 

 

这种情况是1中编程的低级错误, 在项目中是不允许出现.

避免方法也十分简单,  在catch子句集的最后增加1个catch(Exception e)就ok, 因为Exception是所有异常的超类, 只要有异常抛出, 则肯定会捕捉到.

 

 

4.3.2 在catch子句内有return子句.

 

下面例子:

 

假如在f()函数抛出了IOExcepion 异常被捕捉到.

 

 

那么执行路线就是

f()  ->  gg()  -> j() -> h() -> 上一级function

也就说, 这种情况下finally里的子句会在return回上一级function前执行. 而后面的k()就被放弃了.

 

 

4.3.3 finally作用小结.

 

可以看出, finally里的语句, 无论如何都会被执行.

至有两种情况除外, 一是断电, 二是exit函数.

 

在项目中, 我们一般在finally编写一些释放资源的动作, 例如初始化公共变量. 关闭connections, 关闭文件等.

 

4.4 try catch finally里一些要注意的问题.

 

4.4.1 无论如何最多只有1个catch被执行

 

这个上面提到过了, 一旦捕捉到1个异常, 就不会尝试捕捉其他异常.

如果try里面的一段代码可能抛出3种异常A B C,  

首先看它先抛出哪个异常, 如果先抛出A,  如果捕捉到A, 那么就执行catch(A)里的代码. 然后finally.. B和C就没有机会再抛出了.

如果捕捉不到A, 就执行finally{}里的语句后中断当前函数, 抛给上一级函数...(应该避免)

 

 

4.4.2 有可能所有catch都没有被执行

 

两种情况, 1就是没有异常抛出, 另一种就是抛出了异常但是没有捕捉不到(应该避免)

 

1. public int f(int a, int b){  
2.         if (0 == b){  
3.             throw new ArithmeticException("Shit !!! / by zero!");  
4.   
5.         }   
6.   
7.         return a/b;  
8. }  

1. public void g(){  
2.     int i;  
3.     h();  
4.     i = f(); //recevie excepton  
5.     k();  
6. }  

1. public int f(int a, int b){  
2.         if (0 == b){  
3.             throw new IOException("Shit !!! / by zero!");  
4.         }   
5.   
6.         return a/b;  
7.     }  

1. public int f(int a, int b) throws IOException{  
2.         if (0 == b){  
3.             throw new IOException("Shit !!! / by zero!");  
4.         }   
5.   
6.         return a/b;  
7. }  

1. public void g(){  
2.     int i;  
3.     h();  
4.     i = f(); //recevie excepton  
5.     k()  
6. }  

1. public void g(){  
2.     int i = 0;  
3.     h();  
4.     try{  
5.         i = f(); //recevie excepton  
6.     }  
7.     catch(IOException e){  
8.   
9.     }  
10.     k();  
11. }  

1. public void g() throws IOException{  
2.     int i = 0;  
3.     h();  
4.     i = f(); //recevie excepton  
5.     k();  
6. }  

1. package Exception_kng;  
2.   
3. class User_Exception1 extends ArithmeticException{  
4.     public User_Exception1(String Exception_name){  
5.         super(Exception_name);  
6.     }  
7.   
8.     public void printStackTrace(){ //overwrite  
9.         super.printStackTrace();  
10.         System.out.printf("hey man, i am an user_defined excetpion\n");    
11.     }  
12. }  
13.   
14. class Exp6{  
15.     public int f(int a, int b){  
16.         if (0 == b){  
17.             throw new User_Exception1("Shit !!! / by zero!"); //use User_defined exception  
18.         }   
19.   
20.         return a/b;  
21.     }  
22. }  
23.   
24. public class Expt_6{  
25.     public static void g() {  
26.         Exp6 ex = new Exp6();  
27.         int i = 22;  
28.         try{  
29.             i = ex.f(8,0); //throw excetpion   
30.         }catch(User_Exception1 e){  
31.             e.printStackTrace();  
32.         }  
33.         System.out.printf("i is %d\n", i);   
34.         System.out.printf("g() is done!!\n");   
35.     }  
36. }  

1. //openfile  
2. if (fileOpen() > 0){  
3.     //check the length of the file  
4.     if (gotLengthOfTheFile() > 0){  
5.         //check the memory  
6.         if (gotEnoughMemory() > 0){  
7.             //load file to memory  
8.             if (loadFileToMem() > 0){  
9.                 readFile();  
10.             }else{  
11.                 errorCode = -5;  
12.             }  
13.   
14.         }else{  
15.             errorCode = -5;  
16.         }  
17.   
18.     }else{  
19.         errorCode = -5;  
20.     }  
21.   
22. }else{  
23.     errorCode = -5;  
24. }  
25.   
26. //handle error  
27. case errorCode....  
28.   
29. //release Source  
30. releaseSource();  

1. try{  
2.     fileOpen();  
3.     gotLengthOfTheFile();  
4.     gotEnoughMemory();  
5.     loadFileToMem();  
6.     readFile();  
7. }  
8. catch(fileOpenFail) {  handle1()}  
9. catch(gotLengthOfTheFileFail) {  handle2()}  
10. catch(gotEnoughMemoryFail) {  handle3()}  
11. catch(loadFileToMemFail) {  handle4()}  
12. catch(readFileFail) {  handle4()}  
13. catch(Exception e)   {  handle5()} //catch unexpected error  
14. finally{  
15.     releasSource();   
16. }