`

try与finally块中return的问题

try finally return 
阅读更多

针对以下情况进行测试：

情况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;}

 

情况1：try{} catch(){} finally{} return;

package com.lwf.eus.servlet;

public class Test {
 public static void main(String[] args) {
  System.out.print(tt());
 }

 public static int tt() {
  int b = 23;
  try {
   System.out.println("yes");
   b += 88;
  } catch (Exception e) {
   System.out.println("error:" + e);
  } finally {
   if (b > 25) {
    System.out.println("b>25:" + b);
   }
   System.out.println("finally");
  }

  return 101;// ---4
 }
}

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

yes
b>25:111
finally
101

 

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

package com.lwf.eus.servlet;

public class Test {
 public static void main(String[] args) {
  System.out.print(tt());
 }

 public static int tt() {
  int b = 23;
  try {
   System.out.println("yes");
   return b += 88;//---1
  } catch (Exception e) {
   System.out.println("error:" + e);
  } finally {
   if (b > 25) {
    System.out.println("b>25:" + b);
   }
   System.out.println("finally");
  }

  return 101;// ---4
 }
}
程序执行try块中return之前的代码，并执行return语句中的表达式运算；之后再执行finally块，最后执行try中return;  finally块之后的语句---4处的return，因已在1处return而中断，不再执行。

结果：

yes
b>25:111
finally
111

 

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

package com.lwf.eus.servlet;

public class Test {
 public static void main(String[] args) {
  System.out.print(tt());
 }

 public static int tt() {
  int b = 23;
  try {
   System.out.println("yes");
   b += 88;//---1
  } catch (Exception e) {
   System.out.println("error:" + e);
   return b;//---2
  } finally {
   if (b > 25) {
    System.out.println("b>25:" + b);
   }
   System.out.println("finally");
  }

  return 101;// ---4
 }
}

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

yes
b>25:111
finally
101

 


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

package com.lwf.eus.servlet;

public class Test {
 public static void main(String[] args) {
  System.out.print(tt());
 }

 public static int tt() {
  int b = 23;
  try {
   System.out.println("yes");
   return b += 88;//---1
  } catch (Exception e) {
   System.out.println("error:" + e);
  } finally {
   if (b > 25) {
    System.out.println("b>25:" + b);
   }
   System.out.println("finally");
   return 101;// ---4
  }
  
 }
}
序执行try块中return之前（包括return语句中的表达式运算）代码；再执行finally块，因为finally块中有return所以提前退出
结果：

yes
b>25:111
finally
101

 

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

package com.lwf.eus.servlet;

public class Test {
 public static void main(String[] args) {
  System.out.print(tt());
 }

 public static int tt() {
  int b = 23;
  try {
   System.out.println("yes");
   b += 88;//---1
   throw new Exception();
  } catch (Exception e) {
   System.out.println("error:" + e);
   return b+=100; // ---2
  } finally {
   if (b > 25) {
    System.out.println("b>25:" + b);
   }
   System.out.println("finally");
   return b;// ---4
  }
  
 }
}

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

yes
error:java.lang.Exception
b>25:211
finally
211

 

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

有异常且异常发生在try的return之前：程序执行try块中return之前代码（不包括retrun语句中的表达式运算）,再执行catch块中return之前（包括return语句中的表达式运算）代码；则再执行finally块，因为finally块中有return所以提前退出

测试代码如下：

package com.lwf.eus.servlet;

public class Test {
 public static void main(String[] args) {
  System.out.print(tt());
 }

 public static int tt() {
  int b = 23;
  try {
   System.out.println("yes");
   b += 88;//---1
   if(b>0){
    throw new Exception();
   }
   return b+=10;
  } catch (Exception e) {
   System.out.println("error:" + e);
   return b+=100; // ---2
  } finally {
   if (b > 25) {
    System.out.println("b>25:" + b);
   }
   System.out.println("finally");
   return b;// ---4
  }
  
 }
}
结果：

yes
error:java.lang.Exception
b>25:211
finally
211

 


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

测试代码如下：

package com.lwf.eus.servlet;

public class Test {
 public static void main(String[] args) {
  System.out.print(tt());
 }

 public static int tt() {
  int b = 23;
  try {
   System.out.println("yes");
   b += 88;//---1
   return 2/0;
  } catch (Exception e) {
   System.out.println("error:" + e);
   return b+=100; // ---2
  } finally {
   if (b > 25) {
    System.out.println("b>25:" + b);
   }
   System.out.println("finally");
   return b;// ---4
  }
  
 }
}
结果：

yes
error:java.lang.ArithmeticException: / by zero
b>25:211
finally
211


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

测试代码如下：

package com.lwf.eus.servlet;

public class Test {
 public static void main(String[] args) {
  System.out.print(tt());
 }

 public static int tt() {
  int b = 23;
  try {
   System.out.println("yes");
   b += 88;//---1
   return 1;
  } catch (Exception e) {
   System.out.println("error:" + e);
   return b+=100; // ---2
  } finally {
   if (b > 25) {
    System.out.println("b>25:" + b);
   }
   System.out.println("finally");
   return b;// ---4
  }
  
 }
}
结果：

yes
b>25:111
finally
111

 

以上几种情况说明：
一、如果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。

 有关异常机制参见：深入理解java异常处理机制

分享到：
| JAVA解决插入数据库时遇到的引号问题
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java 中finally语句块与return的执行关系

    Java 中 finally 语句块与 return 的执行关系 Java 中的 finally 语句块是用于保证无论出现什么情况，一定要执行的代码块。在 try-catch-finally 结构中，finally 语句块的执行顺序是非常重要的。下面我们来详细...

    try、catch、finally、return 执行顺序.doc

    通过以上分析，我们可以得出结论：任何执行 try 或者 catch 中的 return 语句之后，在返回之前，如果 finally 存在的话，都会先执行 finally 语句，如果 finally 中有 return 语句，那么程序就 return 了。...

    try-finally-return-in-finally.rar_return

    当我们谈论`return`语句与`finally`块的交互时，这是一个关键的议题，因为`return`语句会提前结束函数的执行，但`finally`块中的代码仍然会被执行。 标题“try-finally-return-in-finally.rar_return”暗示了我们...

    try~catch~finally中关于return的问题

    在Java的异常机制中，如果finally中含有return语句，则try和catch中的return语句将会被JVM忽视

    try-catch-finally-return-in-finally.rar_return

    这意味着，如果在 `finally` 块中有 `return`，那么这个 `return` 将覆盖之前 `try` 或 `catch` 中的 `return`，成为函数的最终返回值。 例如，在JavaScript中，以下示例展示了 `try-catch-finally-return-in-...

    try-catch-finally捕获异常

    catch块是try-catch-finally语句的第二部分，用于捕获和处理try块中的异常。catch块可以捕获特定的异常类型，也可以捕获所有类型的异常。catch块的语法结构如下： ```java catch (Exception e) { // 异常处理代码 ...

    使用try-catch-finally处理异常

    即使在`try`或`catch`块中有return语句，`finally`块的代码也会被执行。 5. **多层嵌套** 你还可以在`try-catch-finally`结构内部嵌套另一个`try-catch-finally`结构，以处理更复杂的情况。这种方式使得异常处理...

    try_catch_finally异常处理java

    即使`try`或`catch`块中存在`return`语句，`finally`块的代码也会被执行。这确保了程序的整洁和资源的有效管理。 在Java中，`try-catch-finally`结构可以单独使用，也可以嵌套使用。嵌套的`try-catch-finally`允许...

    Java finally语句到底是在return之前还是之后执行？

    1. 如果`try`块中的代码没有抛出异常，那么`finally`块会在`try`块结束时执行，之后控制权将传递给相应的`return`语句。 2. 如果`try`块中的代码抛出一个未捕获的异常，`finally`块仍然会执行，然后再将异常传递给...

    谈谈Java中try-catch-finally中的return语句

    与代码二类似，`finally`块中的`return 0;`会将0放入返回值区域，所以方法返回0，而不考虑`try`块中的`return`。 总结一下，`try-catch-finally`结构中的`return`语句遵循以下规则： 1. 如果`finally`块没有`return...

    Java中finally块执行与return关系深度剖析

    Java finally语句到底是在return之前还是之后执行？Java finally执行深度剖析，具体看这篇博文：http://blog.csdn.net/lanxuezaipiao/article/details/16922895，这是里面相关的源码，欢迎大家下载使用。

    Jungle68#-#[Java] try catch finally，try里有return，finally还执行么？1

    Condition 3： try中有异常，try-catch-finally里都没有return ，finally 之后有个returntry中有异常以后，根据

    Java中finally和return的关系实例解析

    3. finally语句可以与return语句结合使用，但是finally语句的返回值将覆盖try/catch中的return语句。 4. 在finally中写return语句会有警告，因为它会阻止函数抛出异常，而改为正常返回。 Java中finally和return的...

    关于Java中try finally return语句的执行顺序浅析

    可以看到，finally语句块在try语句块中的return语句之前执行。 finally语句块的执行顺序是非常重要的，需要我们认真地了解和掌握。只有在try语句块得到执行的情况下，finally语句块才会执行，而不是一定会执行的。

    浅谈Java中return和finally的问题

    2. **`return` 与 `finally` 的执行顺序**：在 `try` 块中遇到 `return` 时，会先执行 `finally` 语句块，然后再返回值。这是因为 `finally` 中的代码优先级高于 `return`，即使 `return` 已经被触发，`finally` ...

    try-catch-finally执行顺序验证

    try-catch-finally执行顺序验证(左边是....(2)如果finally中无return则执行return var，finally块中的操作不会影响var的值(如果var的值是对象的内存地址,则finally块的操作可以改变该对象的属性值)。 验证 1.基本类型

    关于Java中的try-catch-finally语句和return

    　第二：finally里面不建议放return语句，根据需要，return语句可以放在try和catch里面和函数的后。可行的做法有四： 　1、return语句只在函数后出现一次。 　2、return语句仅在try和catch里面都出现。 　3、...

    C++ 中try finally关键字详解

    即使在 `try` 块中有 `return` 语句或者 `goto` 语句导致程序流程提前离开，`finally` 块的代码也会被执行。这是 `finally` 关键字的核心特性，确保资源清理逻辑总是能够被执行，比如关闭文件、释放内存等。 以下是...

    try catch finally的执行顺序深入分析

    在这个过程中，函数会将`try`或`catch`块中的`return`语句返回的值暂存起来，然后执行`finally`块。 如果在`finally`块中也有`return`语句，那么这个`return`值会覆盖之前暂存的值。也就是说，最终返回给调用者的值...

    Java异常处理中同时有finally和return语句的执行问题

    由于`finally`块的`return`语句会覆盖`try`块的`return`，所以最终返回的是`finally`块中的`return`语句的结果。 总的来说，Java异常处理中的`finally`块设计用于确保关键操作的执行，而`return`语句用于返回方法的...

Magicbox
Global site tag (gtag.js) - Google Analytics