.

1.2 java里运行时出现的错误

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

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

1.3 java异常的定义

二, java里的异常的分类.

xxxxxx             ArithmeticException

三, java里对异常的处理

3.1 程序猿对有可能出现的异常使用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. return a/b;
6. }

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. return a/b;
6. }

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

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. k();
10. }

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

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. }else{
14. errorCode = -5;
15. }
16. }else{
17. errorCode = -5;
18. }
19. }else{
20. errorCode = -5;
21. }
22. //handle error
23. case errorCode....
24. //release Source
25. 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. }