1. try {
   
2.                 System.out.println("初始x值为"+x);
   
3.                 return x;                        
   
4.               }
   
5.           finally {        
   
6.                  x+=3;
   
7.                         }
   
8.                  return x+=5;//会报错

复制代码

1. try {
   
2.                 System.out.println("初始x值为"+x);
   
3.                 return x;                        
   
4.               }catch(Exception e){}//不写catch，finally之后不能写catch怎么回事
   
5.           finally {        
   
6.                  x+=3;
   
7.                         }
   
8.                  return x+=5;

复制代码

不写catch,在finally之后写return会报错是为什么。

|---try catch finally代码块组合
                                        |---- try catch finally
                                        |---- try catch(多个)，没有必要释放资源，可以不定义finally
                                        |---- try finally 异常无法直接catch处理（直接声明抛出）,但是需要资源关闭，

1. 
   
2. class TryFinallyTest{
   
3.         private int x;
   
4.         public int  method(){
   
5.                 try {
   
6.                           System.out.println("初始x值为"+x);
   
7.                           return x;                        
   
8.                 }
   
9.                
   
10.                 finally {        
    
11.                                 System.out.println("hehe");
    
12.                       //return x+=2 //②      
    
13.                 }
    
14.      //return x+=2;
    
15.          /*
    
16.            这里为什么不能return?
    
17.            finally上没有catch代码块
    
18.            那么
    
19.            ①如果try代码块中的语句发生异常,那么发生的是
    
20.              编译时不被检测异常->RuntimeExcetption类异常
    
21.              (因为非该类型异常要么try..catch要么throws)
    
22.          会在return前执行finally代码块中内容->return
    
23.                  finally下面语句执行不到,
    
24.                  注意在返回时该方法上
    
25.                  会有一个隐式的throws RuntimeException(或其子类)
    
26.            ②如果try代码块中不发生异常,依然会在return前执行finally代码块中内容->return
    
27.                  finally下面语句依然执行不到
    
28.            此时可以把return放在finally中(②),finally代码顺序执行
    
29.            使用finally中的return,不再是try中的return
    
30.          */
    
31.                
    
32.   }
    
33. public static void main(String[] args){
    
34.   System.out.println(new TryFinallyTest().method());
    
35. 
    
36. }
    
37. }

复制代码

1. 
   
2. class TryFinallyTest2{
   
3.         private int x;
   
4.         public int  method(){
   
5.                 try {
   
6.                           //java.io.FileReader fr=new java.io.FileReader("k://abc.txt");//我这个一定发生异常,没有K盘符
   
7.                           //System.out.println(x);
   
8.                           return x;                        
   
9.                 }
   
10.                 catch(java.io.IOException  e){
    
11.                    //System.out.println("文件不存在");
    
12.                 }
    
13.                 finally {        
    
14.                                 //System.out.println("hehe");
    
15.                            
    
16.                 }
    
17.      return x+=2;
    
18.         /*
    
19.      这里之所以可以return,个人能理解,编译器
    
20.          认为该语句有可能被执行到:当try中在return之前发生异常,程序跳转
    
21.          catch对其处理后,程序继续向下执行,如果下面有return语句,那么try中
    
22.          return 不再执行.
    
23.          */
    
24.                
    
25.   }
    
26. public static void main(String[] args){
    
27.   System.out.println(new TryFinallyTest2().method());
    
28.   /*
    
29.   文件不存在
    
30.   hehe
    
31.   2
    
32.   */
    
33. 
    
34. }
    
35. }

复制代码

如果不写catch，最后的return和try中的return会重复，而方法中只能有一个return；但写了catch后，你最后的return是在执行了catch的语句后返回的，因为这时候try中的语句由于被捕捉到异常，所以return执行不到。

这是因为没有写catch的话，该代码在try块中有return，那么方法执行到第一个return就结束了。
后面的finally之后的代码便成了不可达代码。（Unreachable code）
而写了catch之后，就可能因为catch捕获异常，而第一个return并没有执行。
这样后面的return是有可能执行的。故语法上就没有错。
事实上，第一段代码中，第二个return语句放到finally中，语法上也是没有错的。
因为finally中的代码一定会执行。