blocks|key|2073394|text|示例代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2073395|public+static+void+main(String[]+args)+{
++++System.out.println(Test.test());
}

public+static+int+test()+{
++++try+{
++++++++return+0;
++++}
++++finally+{
++++++++System.out.println("something+is+printed");
++++}
}|code-block|syntax|javascript|2073396|输出：|2073397|something+is+printed.+
0|2073398|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Example code:
<pre><code>public static void main(String[] args) {
 System.out.println(Test.test());
}

public static int test() {
 try {
 return 0;
 }
 finally {
 System.out.println(&quot;something is printed&quot;);
 }
}
</code></pre>
Output:
<pre class="lang-none prettyprint-override"><code>something is printed. 
0
</code></pre>

blocks|key|1859803|text|此外，尽管这是一种糟糕的做法，但如果finally块中有一个return语句，它将胜过来自常规块的任何其他返回语句。也就是说，下面的代码块将返回false：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859804|try+{+return+true;+}+finally+{+return+false;+}|code-block|syntax|javascript|1859805|从finally块中抛出异常也是一样的事情。|1859806|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Also, although it's bad practice, if there is a return statement within the finally block, it will trump any other return from the regular block. That is, the following block would return false:

<pre><code>try { return true; } finally { return false; }
</code></pre>

Same thing with throwing exceptions from the finally block.

blocks|key|2074100|text|除了其他响应之外，还必须指出'finally‘有权覆盖try..catch块返回的任何异常/返回值。例如，下面的代码返回12：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2074101|public+static+int+getMonthsInYear()+{
++++try+{
++++++++return+10;
++++}
++++finally+{
++++++++return+12;
++++}
}|code-block|syntax|javascript|2074102|同样，下面的方法不会抛出异常：|2074103|public+static+int+getMonthsInYear()+{
++++try+{
++++++++throw+new+RuntimeException();
++++}
++++finally+{
++++++++return+12;
++++}
}|2074104|而下面的方法确实抛出了它：|2074105|public+static+int+getMonthsInYear()+{
++++try+{
++++++++return+12;++++++++++
++++}
++++finally+{
++++++++throw+new+RuntimeException();
++++}
}|2074106|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

In addition to the other responses, it is important to point out that 'finally' has the right to override any exception/returned value by the try..catch block. For example, the following code returns 12:

<pre><code>public static int getMonthsInYear() {
 try {
 return 10;
 }
 finally {
 return 12;
 }
}
</code></pre>

Similarly, the following method does not throw an exception:

<pre><code>public static int getMonthsInYear() {
 try {
 throw new RuntimeException();
 }
 finally {
 return 12;
 }
}
</code></pre>

While the following method does throw it:

<pre><code>public static int getMonthsInYear() {
 try {
 return 12; 
 }
 finally {
 throw new RuntimeException();
 }
}
</code></pre>

blocks|key|2074406|text|下面是对Kevin's+answer的详细介绍。重要的是要知道，要返回的表达式是在finally之前计算的，即使它是在之后返回的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2074407|public+static+void+main(String[]+args)+{
++++System.out.println(Test.test());
}

public+static+int+printX()+{
++++System.out.println("X");
++++return+0;
}

public+static+int+test()+{
++++try+{
++++++++return+printX();
++++}
++++finally+{
++++++++System.out.println("finally+trumps+return...+sort+of");
++++}
}|code-block|syntax|javascript|2074408|输出：|2074409|X
finally+trumps+return...+sort+of
0|2074410|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/65185/2684342^0|15|7|4|E|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

Here's an elaboration of <a href="https://stackoverflow.com/a/65185/2684342">Kevin's answer</a>. It's important to know that the expression to be returned is evaluated before <code>finally</code>, even if it is returned after.

<pre><code>public static void main(String[] args) {
 System.out.println(Test.test());
}

public static int printX() {
 System.out.println("X");
 return 0;
}

public static int test() {
 try {
 return printX();
 }
 finally {
 System.out.println("finally trumps return... sort of");
 }
}
</code></pre>

Output:

<pre class="lang-none prettyprint-override"><code>X
finally trumps return... sort of
0
</code></pre>

blocks|key|1859158|text|除非存在异常的程序终止(如调用System.exit(0)..)，否则将始终执行。因此，您的sysout将被打印出来|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859159|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

finally is always executed unless there is abnormal program termination (like calling System.exit(0)..). so, your sysout will get printed

blocks|key|1860450|text|不，并非总是有一个异常情况是//+System.exit(0)；在finally块阻止最终执行之前。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1860451|++class+A+{
++++public+static+void+main(String+args[]){
++++++++DataInputStream+cin+=+new+DataInputStream(System.in);
++++++++try{
++++++++++++int+i=Integer.parseInt(cin.readLine());
++++++++}catch(ArithmeticException+e){
++++++++}catch(Exception+e){
+++++++++++System.exit(0);//Program+terminates+before+executing+finally+block
++++++++}finally{
++++++++++++System.out.println("Won't+be+executed");
++++++++++++System.out.println("No+error");
++++++++}
++++}
}|code-block|syntax|javascript|1860452|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

No, not always one exception case is//
System.exit(0);
before the finally block prevents finally to be executed.

<pre><code> class A {
 public static void main(String args[]){
 DataInputStream cin = new DataInputStream(System.in);
 try{
 int i=Integer.parseInt(cin.readLine());
 }catch(ArithmeticException e){
 }catch(Exception e){
 System.exit(0);//Program terminates before executing finally block
 }finally{
 System.out.println("Won't be executed");
 System.out.println("No error");
 }
 }
}
</code></pre>

blocks|key|1859690|text|finally块总是被执行，除非存在异常的程序终止，这是由于JVM崩溃或调用System.exit(0)造成的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1859691|最重要的是，从finally块中返回的任何值都将覆盖在执行finally块之前返回的值，因此在使用try+finally时要小心检查所有退出点。|1859692|entityMap^0|12|E|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

The finally block is always executed unless there is abnormal program termination, either resulting from a JVM crash or from a call to <code>System.exit(0)</code>.

On top of that, any value returned from within the finally block will override the value returned prior to execution of the finally block, so be careful of checking all exit points when using try finally.

blocks|key|2073720|text|另外，在finally中返回将丢弃任何异常。http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2073721|entityMap|0|LINK|mutability|MUTABLE|url|http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html^0|M|20|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Also a return in finally will throw away any exception. <a href="http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html" rel="noreferrer">http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html</a>

blocks|key|1859976|text|最后总是运行，这就是重点，只是因为它出现在返回后的代码中并不意味着它是如何实现的。Java运行时负责在退出try块时运行此代码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1859977|例如，如果您具有以下内容：|1859978|int+foo()+{+
++++try+{
++++++++return+42;
++++}
++++finally+{
++++++++System.out.println("done");
++++}
}|code-block|syntax|javascript|1859979|运行时将生成如下内容：|1859980|int+foo()+{
++++int+ret+=+42;
++++System.out.println("done");
++++return+42;
}|1859981|如果抛出未捕获的异常，则finally块将运行，并且异常将继续传播。|1859982|entityMap^0|1H|3|0|0|0|0|0|C|7|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

Finally is always run that's the whole point, just because it appears in the code after the return doesn't mean that that's how it's implemented. The Java runtime has the responsibility to run this code when exiting the <code>try</code> block.

For example if you have the following:

<pre><code>int foo() { 
 try {
 return 42;
 }
 finally {
 System.out.println("done");
 }
}
</code></pre>

The runtime will generate something like this:

<pre><code>int foo() {
 int ret = 42;
 System.out.println("done");
 return 42;
}
</code></pre>

If an uncaught exception is thrown the <code>finally</code> block will run and the exception will continue propagating.

blocks|key|1859245|text|是的，它会被调用。这就是拥有finally关键字的全部意义所在。如果跳出try/catch块只能跳过finally块，那就等同于将System.out.println放在try/catch之外。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859246|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes it will get called. That's the whole point of having a finally keyword. If jumping out of the try/catch block could just skip the finally block it was the same as putting the System.out.println outside the try/catch.

blocks|key|2073918|text|因为除非您调用System.exit()+(否则线程崩溃)，否则将始终调用finally块。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2073919|entityMap^0|7|D|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Because a finally block will always be called unless you call <code>System.exit()</code> (or the thread crashes).

blocks|key|1860343|text|这是因为您将i的值赋给了12，但没有将i的值返回给函数。正确的代码如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1860344|public+static+int+test()+{
++++int+i+=+0;
++++try+{
++++++++return+i;
++++}+finally+{
++++++++i+=+12;
++++++++System.out.println("finally+trumps+return.");
++++++++return+i;
++++}
}|code-block|syntax|javascript|1860345|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is because you assigned the value of i as 12, but did not return the value of i to the function. The correct code is as follows:

<pre><code>public static int test() {
 int i = 0;
 try {
 return i;
 } finally {
 i = 12;
 System.out.println("finally trumps return.");
 return i;
 }
}
</code></pre>

blocks|key|1860496|text|是的，它会的。无论try或catch代码块中发生了什么，除非调用了System.exit()或JVM崩溃。如果块中有任何返回语句，则最终将在该返回语句之前执行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1860497|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes, it will. No matter what happens in your try or catch block unless otherwise System.exit() called or JVM crashed. if there is any return statement in the block(s),finally will be executed prior to that return statement.

blocks|key|2074448|text|是的会的。唯一不会发生的情况是JVM退出或崩溃。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2074449|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes It will.
Only case it will not is JVM exits or crashes

blocks|key|1860712|text|是的，finally块总是被执行。大多数开发人员使用此块关闭数据库连接、resultset对象、statement对象，也使用java+hibernate回滚事务。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1860713|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes, finally block is always execute. Most of developer use this block the closing the database connection, resultset object, statement object and also uses into the java hibernate to rollback the transaction.

blocks|key|1861060|text|考虑以下程序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1861061|public+class+SomeTest+{

++++private+static+StringBuilder+sb+=+new+StringBuilder();

++++public+static+void+main(String+args[])+{

++++++++System.out.println(someString());
++++++++System.out.println("---AGAIN---");
++++++++System.out.println(someString());
++++++++System.out.println("---PRINT+THE+RESULT---");
++++++++System.out.println(sb.toString());
++++}

++++private+static+String+someString()+{

++++++++try+{
++++++++++++sb.append("-abc-");
++++++++++++return+sb.toString();

++++++++}+finally+{
++++++++++++sb.append("xyz");
++++++++}
++++}
}|code-block|syntax|javascript|1861062|从Java+1.8.162开始，上面的代码块给出了以下输出：|1861063|-abc-
---AGAIN---
-abc-xyz-abc-
---PRINT+THE+RESULT---
-abc-xyz-abc-xyz|1861064|这意味着使用finally释放对象是一种很好的做法，如以下代码所示：|offset|length|style|CODE|1861065|private+static+String+someString()+{

++++StringBuilder+sb+=+new+StringBuilder();

++++try+{
++++++++sb.append("abc");
++++++++return+sb.toString();

++++}+finally+{
++++++++sb+=+null;+//+Just+an+example,+but+you+can+close+streams+or+DB+connections+this+way.
++++}
}|1861066|entityMap^0|0|0|0|0|6|7|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Consider the following program:

<pre><code>public class SomeTest {

 private static StringBuilder sb = new StringBuilder();

 public static void main(String args[]) {

 System.out.println(someString());
 System.out.println("---AGAIN---");
 System.out.println(someString());
 System.out.println("---PRINT THE RESULT---");
 System.out.println(sb.toString());
 }

 private static String someString() {

 try {
 sb.append("-abc-");
 return sb.toString();

 } finally {
 sb.append("xyz");
 }
 }
}
</code></pre>

As of Java 1.8.162, the above code block gives the following output:

<pre><code>-abc-
---AGAIN---
-abc-xyz-abc-
---PRINT THE RESULT---
-abc-xyz-abc-xyz
</code></pre>

this means that using <code>finally</code> to free up objects is a good practice like the following code:

<pre><code>private static String someString() {

 StringBuilder sb = new StringBuilder();

 try {
 sb.append("abc");
 return sb.toString();

 } finally {
 sb = null; // Just an example, but you can close streams or DB connections this way.
 }
}
</code></pre>

blocks|key|1859606|text|实际上，任何language...finally都会在返回语句之前执行，而不管返回语句在方法体中的什么位置。如果不是这样的话，finally块就没有多大意义了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1859607|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

That's actually true in any language...finally will always execute before a return statement, no matter where that return is in the method body. If that wasn't the case, the finally block wouldn't have much meaning.

blocks|key|2073780|text|除了在最后替换try块中的return时的return这一点之外，异常也是如此。抛出异常的finally块将替换从try块中抛出的返回或异常。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2073781|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In addition to the point about return in finally replacing a return in the try block, the same is true of an exception. A finally block that throws an exception will replace a return or exception thrown from within the try block.

blocks|key|2074588|text|finally将会执行，这是肯定的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2074589|在以下情况下，finally将不会执行：|2074590|案例1：|2074591|当您执行System.exit()时。|2074592|案例2：|2074593|当您的JVM+/+Thread崩溃时。|2074594|案例3：|2074595|当您的执行在两者之间手动停止时。|2074596|entityMap^0|0|7|0|7|7|0|0|4|D|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|11|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|15|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|16|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|17|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|18|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|U|$]]

<code>finally</code> will execute and that is for sure.

<code>finally</code> will not execute in below cases: 

case 1 :

When you are executing <code>System.exit()</code>.

case 2 :

When your JVM / Thread crashes.

case 3 : 

When your execution is stopped in between manually.

blocks|key|2074271|text|如果抛出异常，则最终运行。如果没有抛出异常，则最终运行。如果捕获到异常，则最终运行。如果未捕获异常，则最终运行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2074272|只有当JVM退出时，它才不会运行。|2074273|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

If an exception is thrown, finally runs. If an exception is not thrown, finally runs. If the exception is caught, finally runs. If the exception is not caught, finally runs.

Only time it does not run is when JVM exits.

blocks|key|1860694|text|最后块总是执行，无论异常处理与否，在.if块之前发生的任何异常，最后块都不会执行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1860695|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Finally block always execute whether exception handle or not .if any exception occurred before try block then finally block will not execute.

blocks|key|2074044|text|因为决赛总是在任何情况下都会被调用。你没有异常，它仍然被调用，捕获异常，它仍然被调用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2074045|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Because the final is always be called in whatever cases you have. You don't have exception, it is still called, catch exception, it is still called

blocks|key|2074159|text|在正常的执行过程中考虑这一点(即没有抛出任何异常)：如果方法不是“void”，那么它总是显式地返回一些东西，但最终总是会被执行|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2074160|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Consider this in a normal course of execution (i.e without any Exception being thrown): if method is not 'void' then it always explicitly returns something, yet, finally always gets executed

blocks|key|1860814|text|如果Exception在嵌套的finally块中为thrown，也可以过早退出finally。编译器将警告您finally块未正常完成，或者给出一个错误，说明您有无法访问的代码。只有当throw不在条件语句后面或循环内时，才会显示无法访问代码的错误。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1860815|try{
}finally{
+++try{
+++}finally{
++++++//if(someCondition)+-->+no+error+because+of+unreachable+code
++++++throw+new+RunTimeException();
+++}
+++int+a+=+5;//unreachable+code
}|code-block|syntax|javascript|1860816|entityMap^0|2|9|F|7|P|5|13|7|1I|7|2K|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|L|$]]

<code>finally</code> can also be exited prematurely if an <code>Exception</code> is <code>throw</code>n inside a nested <code>finally</code> block. The compiler will warn you that the <code>finally</code> block does not complete normally or give an error that you have unreachable code. The error for unreachable code will be shown only if the <code>throw</code> is not behind a conditional statement or inside a loop.

<pre><code>try{
}finally{
 try{
 }finally{
 //if(someCondition) --&gt; no error because of unreachable code
 throw new RunTimeException();
 }
 int a = 5;//unreachable code
}
</code></pre>

blocks|key|1860858|text|与以下代码相同：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1860859|static+int+f()+{
++++while+(true)+{
++++++++try+{
++++++++++++return+1;
++++++++}+finally+{
++++++++++++break;
++++++++}
++++}
++++return+2;
}|code-block|syntax|javascript|1860860|F将返回2！|1860861|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Same with the following code:

<pre><code>static int f() {
 while (true) {
 try {
 return 1;
 } finally {
 break;
 }
 }
 return 2;
}
</code></pre>

f will return 2!

blocks|key|2074757|text|是的，它将始终被调用，但在一种情况下，当您使用System.exit()时，它不会被调用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2074758|try{
//risky+code
}catch(Exception+e){
//exception+handling+code
}
finally(){
//It+always+execute+but+before+this+block+if+there+is+any+statement+like+System.exit(0);+then+this+block+not+execute.
}|code-block|syntax|javascript|2074759|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Yes it will always called but in one situation it not call when you use System.exit()

<pre><code>try{
//risky code
}catch(Exception e){
//exception handling code
}
finally(){
//It always execute but before this block if there is any statement like System.exit(0); then this block not execute.
}
</code></pre>

blocks|key|2074830|text|最后，即使在try块中放入一条return语句，也会始终执行该块。finally块将在return语句之前执行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2074831|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

finally block is executed always even if you put a return statement in the try block. The finally block will be executed before the return statement.

blocks|key|2074951|text|Finally总是在结束时调用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2074952|当你尝试的时候，它会执行一些代码，如果在try中发生了一些事情，那么catch会捕捉到那个异常，你可以打印一些mssg输出或者抛出一个错误，最后块就会被执行。|2074953|例如，如果您在java中使用扫描仪，则可能应该关闭扫描仪，因为它会导致其他问题，例如无法打开某些文件。|2074954|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Finally is always called at the end

when you try, it executes some code, if something happens in try, then catch will catch that exception and you could print some mssg out or throw an error, then finally block is executed.

Finally is normally used when doing cleanups, for instance, if you use a scanner in java, you should probably close the scanner as it leads to other problems such as not being able to open some file

blocks|key|2074988|text|try-with-resoruce示例|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2074989|static+class+IamAutoCloseable+implements+AutoCloseable+{
++++private+final+String+name;
++++IamAutoCloseable(String+name)+{
++++++++this.name+=+name;
++++}
++++public+void+close()+{
++++++++System.out.println(name);
++++}
}

@Test
public+void+withResourceFinally()+{
++++try+(IamAutoCloseable+closeable1+=+new+IamAutoCloseable("closeable1");
+++++++++IamAutoCloseable+closeable2+=+new+IamAutoCloseable("closeable2"))+{
++++++++System.out.println("try");
++++}+finally+{
++++++++System.out.println("finally");
++++}
}|code-block|syntax|javascript|2074990|测试输出：|2074991|try
closeable2
closeable1
finally|2074992|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

try-with-resoruce example

<pre><code>static class IamAutoCloseable implements AutoCloseable {
 private final String name;
 IamAutoCloseable(String name) {
 this.name = name;
 }
 public void close() {
 System.out.println(name);
 }
}

@Test
public void withResourceFinally() {
 try (IamAutoCloseable closeable1 = new IamAutoCloseable("closeable1");
 IamAutoCloseable closeable2 = new IamAutoCloseable("closeable2")) {
 System.out.println("try");
 } finally {
 System.out.println("finally");
 }
}
</code></pre>

Test output:

<pre><code>try
closeable2
closeable1
finally
</code></pre>

blocks|key|2075036|text|我在这里回答得太晚了，但令我惊讶的是，没有人提到Java调试器选项来删除堆栈帧。我是IntelliJ中这个功能的重度用户。(我相信Eclipse和NetBeans都支持相同的特性。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2075037|如果我从try或catch块中删除堆栈帧，然后是finally块，IDE将提示我：“我应该执行finally块吗？”显然，这是一个人工的运行时环境--调试器！|2075038|为了回答你的问题，我想说你只能保证在附加调试器时忽略它，并且(就像其他人所说的)方法something()不会(a)调用System.exit(int)方法或者(b)通过JNI调用C函数exit(int)+/+abort()，或者(c)做一些疯狂的事情，比如调用kill+-9+$PID本身(！)。|offset|length|style|CODE|2075039|entityMap^0|0|0|16|B|1O|G|2L|9|2X|7|3N|C|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@$F|O|G|P|H|I]|$F|Q|G|R|H|I]|$F|S|G|T|H|I]|$F|U|G|V|H|I]|$F|W|G|X|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$]]

I am terribly late to answer here, but I am surprised that no one mentioned the Java debugger option to drop a stack frame. I am a heavy user of this feature in IntelliJ. (I am sure Eclipse and NetBeans has support for the same feature.)
If I drop stack frame from a the try or catch block that is followed by a finally block, the IDE will prompt me: &quot;Shall I execute the finally block?&quot; Obviously, this is an artificial runtime environment -- a debugger!
To answer your question, I would say you can only guarantee it runs if ignore when a debugger is attached, and (like others said) method <code>something()</code> does not (a) call Java method <code>System.exit(int)</code> or (b) C function <code>exit(int)</code> / <code>abort()</code> via JNI or (c) do something crazy like call <code>kill -9 $PID</code> on itself(!).

blocks|key|1861229|text|accepted+answer在几乎所有方面都是正确的，但它仍然只是事实的一半(好吧，95%25的事实)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1861230|假设代码如下：|1861231|private+final+Lock+m_Lock+=+new+ReentrantLock();
…
public+final+SomeObject+doSomething(+final+SomeObject+arg+)
{
++final+SomeObject+retValue;
++try
++{
++++lock.lock();
++++retValue+=+SomeObject(+arg+);
++}
++finally
++{
++++out.println(+"Entering+finally+block");
++++callingAnotherMethod(+arg,+retValue+);
++++lock.unlock();
++}
++
++return+retValue;
}
…
try
{
+++final+var+result+=+doSomething(+new+SomeObject()+);
}
catch(+final+StackOverflowError+e+)+{+/*+Deliberately+ignored+*/+}|code-block|syntax|javascript|1861232|调用方法doSomething()几乎会立即导致StackOverflowError。|style|CODE|1861233|lock是不会发布的！|1861234|但是，当finally块总是被执行时(accepted+answer中已经列出了异常)，怎么会发生这种情况呢？|1861235|这是因为不能保证finally块中的所有语句都能真正执行！|1861236|如果在调用lock.unlock()之前调用System.exit()或throws语句，这将是显而易见的。|1861237|但在示例代码…中没有类似的内容|1861238|此外，在调用lock.unlock()之前，finally块中的另外两个方法调用将导致另一个StackOverflowError…|1861239|瞧，锁并没有被释放！|1861240|尽管示例代码本身是愚蠢的，但在许多类型的软件中都可以找到许多类似的模式。只要finally块…中没有丑陋的事情发生，一切都会正常工作|1861241|有趣的事实是，它不能在更高版本的Java中工作(这意味着在更高版本中，锁是…发布的)。不知道这是什么时候和为什么改变的。|1861242|但是，您仍然必须确保finally块始终正常终止，否则，即使它总是以…方式执行，也可能无关紧要|1861243|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/65049/1554195|1^0|0|F|0|0|0|0|4|D|O|I|0|0|4|0|4|7|J|F|1|0|8|7|0|5|D|M|D|10|6|0|0|6|D|M|7|1A|I|0|0|12|7|0|0|A|7|0^^$0|@$1|2|3|4|5|6|7|1H|8|@]|9|@$A|1I|B|1J|1|1K]]|C|$]]|$1|D|3|E|5|6|7|1L|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1M|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1N|8|@$A|1O|B|1P|M|N]|$A|1Q|B|1R|M|N]]|9|@]|C|$]]|$1|O|3|P|5|6|7|1S|8|@$A|1T|B|1U|M|N]]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1V|8|@$A|1W|B|1X|M|N]]|9|@$A|1Y|B|1Z|1|20]]|C|$]]|$1|S|3|T|5|6|7|21|8|@$A|22|B|23|M|N]]|9|@]|C|$]]|$1|U|3|V|5|6|7|24|8|@$A|25|B|26|M|N]|$A|27|B|28|M|N]|$A|29|B|2A|M|N]]|9|@]|C|$]]|$1|W|3|X|5|6|7|2B|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|6|7|2C|8|@$A|2D|B|2E|M|N]|$A|2F|B|2G|M|N]|$A|2H|B|2I|M|N]]|9|@]|C|$]]|$1|10|3|11|5|6|7|2J|8|@]|9|@]|C|$]]|$1|12|3|13|5|6|7|2K|8|@$A|2L|B|2M|M|N]]|9|@]|C|$]]|$1|14|3|15|5|6|7|2N|8|@]|9|@]|C|$]]|$1|16|3|17|5|6|7|2O|8|@$A|2P|B|2Q|M|N]]|9|@]|C|$]]|$1|18|3|-4|5|6|7|2R|8|@]|9|@]|C|$]]]|19|$1A|$5|1B|1C|1D|C|$1E|1F]]|1G|$5|1B|1C|1D|C|$1E|1F]]]]

The <a href="https://stackoverflow.com/a/65049/1554195">accepted answer</a> is true in nearly all aspects, but it is still only halve the truth at all (ok, 95% of the truth).
Assume the following code:
<pre><code>private final Lock m_Lock = new ReentrantLock();
…
public final SomeObject doSomething( final SomeObject arg )
{
 final SomeObject retValue;
 try
 {
 lock.lock();
 retValue = SomeObject( arg );
 }
 finally
 {
 out.println( &quot;Entering finally block&quot;);
 callingAnotherMethod( arg, retValue );
 lock.unlock();
 }
 
 return retValue;
}
…
try
{
 final var result = doSomething( new SomeObject() );
}
catch( final StackOverflowError e ) { /* Deliberately ignored */ }
</code></pre>
Calling the method <code>doSomething()</code> will cause a <code>StackOverflowError</code> nearly immediately.
And the <code>lock</code> will not be released!
But how could this happen when the <code>finally</code> block is always executed (with the exceptions already listed in the <a href="https://stackoverflow.com/a/65049/1554195">accepted answer</a>)?
That is because there is no guarantee made that all statements in the <code>finally</code> block are really executed!
This would be obvious if there would be a call to <code>System.exit()</code> or a <code>throws</code> statement before the call to <code>lock.unlock()</code>.
But there is nothing like that in the sample code …
Aside that the two other method calls in the <code>finally</code> block before the call to <code>lock.unlock()</code> will cause another <code>StackOverflowError</code> …
And voilà, the lock is not released!
Although the sample code as such is silly, similar patterns can be found a lot in many kinds of software. All works fine as long as nothing ugly happens in the <code>finally</code> block …
Funny fact is that it does not work in later versions of Java (meaning that in later versions, the lock was released …). No idea when and why this changed.
But you still have to make sure that the <code>finally</code> block always terminates normally, otherwise it might not matter if (that) it always get executed …

Considering this code, can I be absolutely sure that the <code>finally</code> block always executes, no matter what <code>something()</code> is?

<pre><code>try { 
 something(); 
 return success; 
} 
catch (Exception e) { 
 return failure; 
} 
finally { 
 System.out.println("I don't know if this will get printed out");
}
</code></pre>

Does a finally block always get executed in Java?

考虑到这段代码，我能绝对确定无论something()是什么，finally块都会执行吗？try {      something();      return success;  }  catch (Exception e) {       return failure;  }  finally {      System.out.println("I don't know if this wi

问finally代码块总是在Java中执行吗？
EN

回答 31

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问finally代码块总是在Java中执行吗？EN

回答 31

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问finally代码块总是在Java中执行吗？
EN