1. 
   

复制代码

1. finally{                // 关闭资源
   
2.         try {
   
3.                 if(bufi!=null)
   
4.                 bufi.close();                        
   
5.                  }
   
6.         catch (IOException e) {
   
7.                  throw new RuntimeException("读取关闭失败");
   
8.                 }
   
9.          finally{  
   
10.                 try {
    
11.                         if(bufi!=null)
    
12.                         bufi.close();                        
    
13.                          }
    
14.                 catch (IOException e) {
    
15.                          throw new RuntimeException("读取关闭失败");
    
16.                         }
    
17.                 }
    
18. }

复制代码

刚才代码赋值错了抱歉
上面这个代码是关流的时候的操作，编译可以通过，如果bufi.close();出现了异常，那么下面的那个finally块是不是不执行了？
会出现这个问题么？

下面那个try块是不会执行；
可能会出现这个问题，小概率事件

肯定不会执行啊...程序一遇到异常就直接停止了.不向下执行了.

可以规避掉的

使用finally  关键字，  把这个问题规避掉！

1. finally
   
2. {                // 关闭资源
   
3.         //分级处理问题，这样每个问题都会处理！
   
4.        
   
5.         try
   
6.         {
   
7.         //第一级，测试代码，检查是否有异常。
   
8.                 if(bufi!=null)
   
9.                 bufi.close();                        
   
10.         }
    
11.        
    
12.         catch (IOException e)
    
13.         {
    
14.                 //发现异常，捕捉异常，并处理第一级异常
    
15.                 throw new RuntimeException("读取关闭失败");
    
16.         }
    
17.         finally
    
18.         {
    
19.                 //执行第二级 ，测试代码，检查异常
    
20.                 try
    
21.                 {
    
22.                         //测试代码块
    
23.                         if(bufo!=null)
    
24.                         bufo.close();
    
25.                 }
    
26.                 catch (IOException e)
    
27.                 {
    
28.                         throw new RuntimeException("写入关闭失败");
    
29.                 }
    
30.                 //如果后续还有还可以延续，至于这样处理是不是最优化的就不知道了
    
31.         }
    
32. }

复制代码

{:soso_e103:}这个都会执行吧，异常终止只是针对当前try的块里，io异常捕获后会继续往下执行。。。你可以测试下io异常发生后会不会继续往下执行

1.         public static void main(String[] args) {
   
2.                
   
3.                 try {
   
4.                         throw new IOException();
   
5.                 }catch (IOException e) {
   
6.                         e.printStackTrace();
   
7.                 }
   
8.                
   
9.                 try{
   
10.                         throw new RuntimeException();
    
11.                 }catch(Exception e) {
    
12.                         System.out.println("catch");
    
13.                 }
    
14.         }

复制代码

会执行，我模拟了下，看这个：
你这个如果关闭流失败，应该只抛出下面那个异常，因为finally肯定要执行，而finally中抛出运行时异常会使程序终止，不能返回执行上面那个catch了！
PS：在通常情况下，不要在finally块中使用如return或throw等导致方法终止的语句，否则会导致try块、catch块中的return、throw语句失效。

1. pspublic class Test
   
2. {
   
3. public static void main(String[] args)
   
4. {
   
5.   int[] arr=new int [2];
   
6.   
   
7.   try
   
8.   {
   
9.    System.out.println(arr[3]);//数组角标越界肯定出异常
   
10.   }
    
11.   catch (Exception e)
    
12.   {
    
13.    throw new RuntimeException("出现异常！(上面)");
    
14.   }
    
15.   finally
    
16.   {
    
17.    try
    
18.    {
    
19.     System.out.println(arr[3]);
    
20.    }
    
21.    catch (Exception e2)
    
22.    {
    
23.     throw new RuntimeException("出现异常！（下面）");
    
24.    }
    
25.   }
    
26. //输出结果是：
    
27. //  Exception in thread "main" java.lang.RuntimeException: 出现异常！（下面）
    
28. //  at com.forum.test.Test.main(Test.java:26)
    
29. }
    
30. }
    

复制代码

关于try{}catch(){}finally{}语块:
try{}语块是可能发异常的代码,如果发生异常,则跳到catch语块中,否则不会执行catch语块.
catch(){}语块除非try{}语块中有异常才会被执行到.
finally{}语块是无论如何都要执行的代码块.
那么上述问题中如果bufi.close();出现了异常,是不会影响到finally{}语块中代码的执行的,
所以,finally{}语块中的代码还是会执行的.

finally 块中  第一个关闭流资源如果没有出现异常  而第二个关闭流资源出现异常

无语了！！！
楼主，我对你真是无语了！
昨天，我看楼主的代码还不是这个样子的！
今天怎么就变了？？？

江华 发表于 2013-2-22 20:35
无语了！！！
楼主，我对你真是无语了！
昨天，我看楼主的代码还不是这个样子的！

抱歉，昨天复制错了

哎！没关系啦！
你的问题找到答案就好，至于技术分给谁了，无所谓了！