blocks|key|2685202|text|因为如果异常被抛出，则在try+块之后不会执行任何代码，除非捕获该异常。无论try块中发生了什么，finally块都会被执行。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|2685203|entityMap^0|C|3|G|1|C|3|12|3|1D|7|0^^$0|@$1|2|3|4|5|6|7|I|8|@$9|J|A|K|B|C]|$9|L|A|M|B|C]|$9|N|A|O|B|D]|$9|P|A|Q|B|D]|$9|R|A|S|B|D]]|E|@]|F|$]]|$1|G|3|-4|5|6|7|T|8|@]|E|@]|F|$]]]|H|$]]

Because if an exception gets thrown no code after the <code>try</code> block is executed unless the exception is caught. A <code>finally</code> block is always executed no matter what happens inside your <code>try</code> block.

blocks|key|2685272|text|看看你的catch块--它会抛出DAOException。因此，即使在您给出的示例中，catch块之后的语句也不会被执行。您所展示的(将一个异常包装在另一个中)是一种常见的模式--但另一种可能是catch块“意外”抛出了一个异常，例如，因为它发出的一个调用失败了。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2685273|此外，可能还有其他未捕获的异常--要么是因为您已声明该方法会抛出这些异常，要么是因为它们是未检查的异常。您真的想因为IllegalArgumentException被抛出到某个地方而泄漏资源吗？|2685274|entityMap^0|G|C|0|1M|O|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|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

Look at your catch block - it's going to throw <code>DAOException</code>. So the statements after your catch block aren't going to be executed even in the sample you've given. What you've shown (wrapping one exception in another) is one common pattern - but another possibility is that the catch block "accidentally" throws an exception, e.g. because one of the calls it makes fails.

Additionally, there may be other exceptions you don't catch - either because you've declared that the method throws them, or because they're unchecked exceptions. Do you really want to leak resources because an <code>IllegalArgumentException</code> got thrown somewhere?

blocks|key|4288061|text|因为如果抛出异常，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4288062|当异常向外传播时，finally子句中的|4288063|代码将执行，即使异常中止了try/catch块之后的其余方法execution;|unordered-list-item|4288064|Code也不会执行，除非异常被catch块捕获且不会重新引发。|4288065|4288066|entityMap^0|0|0|0|0|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|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|O|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Because if an exception is thrown,

<ul>
<li>Code in the finally clause will execute as the exception propagates outward, even if the exception aborts the rest of the method execution;</li>
<li>Code after the try/catch block will not get executed unless the exception is caught by a catch block and not rethrown.</li>
</ul>

blocks|key|618497|text|因为它确保了finally块中的东西得到执行。catch之后的内容可能不会执行，例如，catch块中有另一个异常，这是很有可能的。或者你只是做你做过的事情，然后抛出一个包装原始异常的异常。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|618498|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 it ensures that the stuff in the finally block gets executed. Stuff after catch might not get executed, say, for example, there is another exception in the catch block, which is very possible. Or you just do what you did, and throw an exception wrapping the original exception.

blocks|key|2685660|text|根据HeadFirst的说法，即使try或catch块有返回语句，finally块也会运行。流程跳转到finally，然后返回返回。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2685661|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|$]]

According to HeadFirst Java, a finally block will run even if the try or catch block has a return statement. Flow jumps to finally and then back to return.

blocks|key|618660|text|finally关键字保证代码被执行。在下面的示例中，没有执行close语句。在上面的示例中，它们被执行(这是您想要的！)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|618661|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|$]]

The finally keyword guarantees that the code is executed. In your bottom example, the close statements are NOT executed. In the top example, they are executed (what you want!)

blocks|key|4287901|text|您的第二种方法不会执行“close”语句，因为它已经离开了方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4287902|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|$]]

Your second approach won't do the 'close' statements because it is already left the method.

blocks|key|1661179|text|这是避免资源泄漏的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1661180|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|$]]

This is the way to avoid resource leaks

blocks|key|1659262|text|如果你捕获了所有错误，应该没有区别，否则，只执行finally块内的代码，因为代码执行顺序是:+finally+code+->+error在catch之后抛出->代码因此，一旦你的代码抛出任何未处理的错误，只有finally代码块才能按预期工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1659263|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|$]]

If you catch all errors, there should no difference, otherwise, only code inside finally block is executed because the code execution sequence is:
finally code -> error throw -> code after catch
hence, once your code throw any unhandled error, only finally code block works as expected.

blocks|key|618643|text|在从catch块重新抛出异常之前，将调用finally块中的代码。这确保了您放入finally块中的任何清理代码都会被调用。最终块之外的代码将不会运行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|618644|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|$]]

The code in the finally block will get called before the exception is rethrown from the catch block. This ensures that any cleanup code that you've put in the finally block gets called. Code outside of the finally block will not be run.

blocks|key|1661239|text|这可能会澄清：http://www.java2s.com/Code/Java/Language-Basics/Finallyisalwaysexecuted.htm|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1661240|entityMap|0|LINK|mutability|MUTABLE|url|http://www.java2s.com/Code/Java/Language-Basics/Finallyisalwaysexecuted.htm^0|7|23|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]]]]

this might clarify: <a href="http://www.java2s.com/Code/Java/Language-Basics/Finallyisalwaysexecuted.htm" rel="nofollow">http://www.java2s.com/Code/Java/Language-Basics/Finallyisalwaysexecuted.htm</a>

blocks|key|1661273|text|考虑到catch可以向调用堆栈中的更高级别的函数抛出异常。这将导致在向上层抛出异常之前调用final。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1661274|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 the catch can throw an exception to the higher level functions in the call stack. This will lead calling final before throwing the exception to the upper level.

blocks|key|618828|text|在http://docs.oracle.com/javase/tutorial/essential/exceptions/finally.html中，这是误导性的(并且可能是这个问题的根源)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|618829|The+try+block+of+the+writeList+method+that+you've+been+working+with+here+opens+a+PrintWriter.+The+program+should+close+that+stream+before+exiting+the+writeList+method.+This+poses+a+somewhat+complicated+problem+because+writeList's+try+block+can+exit+in+one+of+three+ways.|style|CODE|618830|1.+The+new+FileWriter+statement+fails+and+throws+an+IOException.
2.+The+list.get(i)+statement+fails+and+throws+an+IndexOutOfBoundsException.
3.+Everything+succeeds+and+the+try+block+exits+normally.|code-block|syntax|javascript|618831|缺少第4路(抛出IOException和IndexOutOfBoundsException以外的异常)。上一页中描述的代码在求助于finally之前仅捕获(1)和(2)。|BOLD|618832|我也是Java新手，在找到这篇文章之前，我也有过同样的疑问。一般来说，潜在记忆倾向于更多地依附于例子而不是理论。|618833|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/tutorial/essential/exceptions/finally.html^0|1|20|0|0|0|7I|0|0|2|3|8|B|K|P|1T|7|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@$A|14|B|15|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|16|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|17|8|@$A|18|B|19|F|O]|$A|1A|B|1B|F|G]|$A|1C|B|1D|F|G]|$A|1E|B|1F|F|G]]|9|@]|C|$]]|$1|P|3|Q|5|6|7|1G|8|@]|9|@]|C|$]]|$1|R|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]]]

In <a href="http://docs.oracle.com/javase/tutorial/essential/exceptions/finally.html" rel="nofollow">http://docs.oracle.com/javase/tutorial/essential/exceptions/finally.html</a> this is misleading (and may have originated the question):

<code>The try block of the writeList method that you've been working with here opens a PrintWriter. The program should close that stream before exiting the writeList method. This poses a somewhat complicated problem because writeList's try block can exit in one of three ways.</code>

<pre><code>1. The new FileWriter statement fails and throws an IOException.
2. The list.get(i) statement fails and throws an IndexOutOfBoundsException.
3. Everything succeeds and the try block exits normally.
</code></pre>

The 4th way (an exception other than <code>IOException</code> and <code>IndexOutOfBoundsException</code> is thrown) is missing. The code depicted in the preceding page only catches (1) and (2) before resorting to <code>finally</code>.

I'm also new to Java and had the same questioning before finding this article. Latent memory tend to attach itself more to examples than to theory, in general.

blocks|key|1661301|text|finally块可能并不总是运行，请考虑下面的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1661302|public+class+Tester+{
++++public+static+void+main(String[]+args)+{
++++++++try+{
++++++++++++System.out.println("The+main+method+has+run");
++++++++++++System.exit(1);
++++++++}+catch+(Exception+e)+{
++++++++++++e.printStackTrace();
++++++++}+finally+{
++++++++++++System.out.println("The+finally+block+has+run");
++++++++}
++++}
}|code-block|syntax|javascript|1661303|在您的例子中，我建议将finally块中的代码包装到try/catch中，因为这段代码可能会抛出异常。|1661304|++++}+catch+(SQLException+sqle)+{
++++++++sqle.printStackTrace();
++++}+finally+{
+++++try+{
++++++++cs.close();
++++++++rs.close();
+++++}+catch+(Exception+e)+{
++++++//handle+new+exception+here
++++}|1661305|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|$]]

The finally block may not always run, consider the following code.

<pre><code>public class Tester {
 public static void main(String[] args) {
 try {
 System.out.println("The main method has run");
 System.exit(1);
 } catch (Exception e) {
 e.printStackTrace();
 } finally {
 System.out.println("The finally block has run");
 }
 }
}
</code></pre>

In your case, I would suggest to wrap the code inside finally block into try/catch, as this code apparently may throw an exception.

<pre><code> } catch (SQLException sqle) {
 sqle.printStackTrace();
 } finally {
 try {
 cs.close();
 rs.close();
 } catch (Exception e) {
 //handle new exception here
 }
</code></pre>

Why do this 

<pre><code>} catch (SQLException sqle) {
 sqle.printStackTrace();
} finally {
 cs.close();
 rs.close();
}
</code></pre>

Instead of this

<pre><code>} catch (SQLException sqle) {
 sqle.printStackTrace();
}
rs.close();
cs.close();
</code></pre>

Why use finally instead of code after catch

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

为什么要这样做？} catch (SQLException sqle) {    sqle.printStackTrace();} finally {    cs.close();    rs.close();}而不是这个} catch (SQLException sqle) {    sqle.printStackTrace();}rs.close();cs.close();

问为什么在catch之后使用finally而不是code
EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在catch之后使用finally而不是codeEN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在catch之后使用finally而不是code
EN