zoukankan      html  css  js  c++  java

  • try与finally块中return的问题

    以前面试有人问过我这个问题，今天在网上看到相关的文章，因为自己也不甚理解所以自我测试，也对网上一些测试结果发表一些看法！
    情况1：try{} catch(){} finally{} return;

    1. package com.lwf.eus.servlet;
    3. public class Test{  
    4.     public static void main(String[] args){
    5.          System.out.print(tt());   
    6.     }   
    7.     public static int tt(){   
    8.          int b = 23;   
    9.          try{   
    10.              System.out.println("yes");
    11.              b += 88;
    12.          }catch(Exception e){   
    13.              System.out.println("error :" + e);
    14.          }finally{   
    15.               if(b>25){   
    16.                   System.out.println("b>25 :"+b);   
    17.               }   
    18.               System.out.println("finally");   
    19.          }
    20.          
    21.          return 101;             //---4
    22.     }
    23. }

    显然程序按顺序执行，最后return 101退出
    结果：

    1. yes
    2. b>25 :111
    3. finally
    4. 101

    情况2:try{ return; } catch(){} finally{} return;

    1. package com.lwf.eus.servlet;
    3. public class Test{  
    4.     public static void main(String[] args){
    5.          System.out.print(tt());   
    6.     }   
    7.     public static int tt(){   
    8.          int b = 23;   
    9.          try{   
    10.              System.out.println("yes");
    11.              b += 88;
    12.              return b;            //---1
    13.          }catch(Exception e){   
    14.              System.out.println("error :" + e);
    15.          }finally{   
    16.               if(b>25){   
    17.                   System.out.println("b>25 :"+b);   
    18.               }   
    19.               System.out.println("finally");   
    20.          }
    21.          
    22.          return 101;             //---4
    23.     }
    24. }

    程序执行try块中return之前（包括return语句中的表达式运算）代码；再执行finally块，最后执行try中return;
    finally块之后的语句，这里的4处return，因为程序在1处已经return所以不再执行。
    结果：

    1. yes
    2. b>25 :111
    3. finally
    4. 111

    情况3:try{ } catch(){ return;} finally{} return;

    1. package com.lwf.eus.servlet;
    3. public class Test{  
    4.     public static void main(String[] args){
    5.          System.out.print(tt());   
    6.     }   
    7.     public static int tt(){   
    8.          int b = 23;   
    9.          try{   
    10.              System.out.println("yes");
    11.              b += 88;
    12.          }catch(Exception e){   
    13.              System.out.println("error :" + e);
    14.              return b;            //---2
    15.          }finally{   
    16.               if(b>25){   
    17.                   System.out.println("b>25 :"+b);   
    18.               }   
    19.               System.out.println("finally");   
    20.          }
    21.          
    22.          return 101;             //---4
    23.     }
    24. }

    程序先执行try，如果遇到异常执行catch块，
        有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，最后执行
    catch块中return. finally之后也就是4处的代码不再执行。
        无异常：执行完try再finally再return.
    结果：本次为无异常结果（当然本示例没有设计异常）

    1. yes
    2. b>25 :111
    3. finally
    4. 101

    情况4:try{ return; } catch(){} finally{return;}

    1. package com.lwf.eus.servlet;
    3. public class Test{  
    4.     public static void main(String[] args){
    5.          System.out.print(tt());   
    6.     }   
    7.     public static int tt(){   
    8.          int b = 23;   
    9.          try{   
    10.              System.out.println("yes");
    11.              b += 88;
    12.              return b;            //---1
    13.          }catch(Exception e){   
    14.              System.out.println("error :" + e);
    15.          }finally{   
    16.               if(b>25){   
    17.                   System.out.println("b>25 :"+b);   
    18.               }   
    19.               System.out.println("finally");   
    20.               return 100;        //---3
    21.          }
    22.          
    23.     }
    24. }

    程序执行try块中return之前（包括return语句中的表达式运算）代码；再执行finally块，因为finally块中有return所以提前退出
    结果：

    1. yes
    2. b>25 :111
    3. finally
    4. 100


    情况5:try{} catch(){return;} finally{return;}

    1. package com.lwf.eus.servlet;
    3. public class Test{  
    4.     public static void main(String[] args){
    5.          System.out.print(tt());   
    6.     }   
    7.     public static int tt(){   
    8.          int b = 23;   
    9.          try{   
    10.              System.out.println("yes");
    11.              b += 88;
    12.          }catch(Exception e){   
    13.              System.out.println("error :" + e);
    14.              return b;            //---2
    15.          }finally{   
    16.               if(b>25){   
    17.                   System.out.println("b>25 :"+b);   
    18.               }   
    19.               System.out.println("finally");   
    20.               return 100;        //---3
    21.          }
    22.          
    23.     }
    24. }

    程序执行catch块中return之前（包括return语句中的表达式运算）代码；再执行finally块，因为finally块中有return所以提前退出
    结果：

    1. yes
    2. b>25 :111
    3. finally
    4. 100


    情况6:try{ return;} catch(){return;} finally{return;}

    1. package com.lwf.eus.servlet;
    3. public class Test{  
    4.     public static void main(String[] args){
    5.          System.out.print(tt());   
    6.     }   
    7.     public static int tt(){   
    8.          int b = 23;   
    9.          try{   
    10.              System.out.println("yes");
    11.              b += 88;
    12.              return b;            //---1
    13.          }catch(Exception e){   
    14.              System.out.println("error :" + e);
    15.              return b;            //---2
    16.          }finally{   
    17.               if(b>25){   
    18.                   System.out.println("b>25 :"+b);   
    19.               }   
    20.               System.out.println("finally");   
    21.               return 100;        //---3
    22.          }
    23.          
    24.     }
    25. }

    程序执行try块中return之前（包括return语句中的表达式运算）代码；
       有异常:执行catch块中return之前（包括return语句中的表达式运算）代码；则再执行finally块，因为finally块中有return所以提前退出
       无异常：则再执行finally块，因为finally块中有return所以提前退出
    无异常结果：

    1. yes
    2. b>25 :111
    3. finally
    4. 100


    以下情况
    情况1：try{} catch(){} finally{} return;
    情况2:try{ return; } catch(){} finally{} return;
    情况3:try{} catch(){ return;} finally{} return;
    情况4:try{ return; } catch(){} finally{return;} 
    情况5:try{} catch(){return;} finally{return;} 
    情况6:try{ return;} catch(){return;} finally{return;} 

    以上几种情况说明：
    一、如果try catch finally块均无return则执行最后finally外的return；如果try catch finally中任何一个有return则最后finally外的return不再执行；
    二、只要finally块中有return则try或catch中的return不再执行

    以下几种情况在finally块的后面是不能出现return的。
    情况:try{} catch(){} finally{ return;} return;
    情况:try{ return; } catch(){} finally{return;} return;
    情况:try{} catch(){return;} finally{return;} return;
    情况:try{ return; } catch(){return;} finally{} return;
    情况:try{ return; } catch(){return;} finally{return;} return;

    上 面几种情况因为finally块中已有return，而且是必须执行的，所以finally外的return必定不能执行，所以编译器提示错误。特殊的 try{ return; } catch(){return;} finally{} return;是因为try和catch中都有return所以必定会执行其中一个，所以finally外的return不能执行，所以编译器提示错误。

    还有一种情况：


    最终结论：任何调用try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的，编译器把finally中的return实现为一个warning。
  • 相关阅读:
    CF 526F Max Mex(倍增求LCA+线段树路径合并)
    CoderForces Round526 (A~E)题解
    牛客OI周赛4-提高组 A K小生成树(kmst)
    Codeforces 1072 C
    Codeforces 1053 C
    牛客国庆集训派对Day3 B Tree
    牛客国庆集训派对Day3 I Metropolis
    牛客国庆集训派对Day3 A Knight
    牛客国庆集训派对Day3 G Stones
    Codeforces 1053 B
  • 原文地址：https://www.cnblogs.com/hzcya1995/p/13318106.html
Copyright © 2011-2022 走看看