为什么我们使用finally块？

发布于 2024-09-12 23:57:57 字数 311 浏览 6 评论 0原文

据我所知，以下两个代码片段都具有相同的目的。为什么要有 finally 块？

代码A：

try { /* Some code */ }
catch { /* Exception handling code */ }
finally { /* Cleanup code */ }

代码B：

try { /* Some code */ }
catch { /* Exception handling code */ }
// Cleanup code

原文

As far as I can tell, both of the following code snippets will serve the same purpose. Why have finally blocks at all?

Code A:

try { /* Some code */ }
catch { /* Exception handling code */ }
finally { /* Cleanup code */ }

Code B:

try { /* Some code */ }
catch { /* Exception handling code */ }
// Cleanup code

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

断爱 2024-09-19 23:57:57

如果抛出您未处理的异常会发生什么？（我希望你没有捕获Throwable...）
如果你从 try 块内部返回会发生什么？
如果 catch 块抛出异常会发生什么？

一个finally块确保但是您退出该块（以几种显式中止整个过程的方式为模），它将被执行。这对于确定性的资源清理非常重要。

回复收藏 0 原文

旧城烟雨 2024-09-19 23:57:57

请注意（至少在 Java 中，也可能在 C# 中）也可以有一个没有 catch 的 try 块，但有一个 finally 。当 try 块中发生异常时，finally 块中的代码将在异常向上抛出之前运行：

InputStream in = new FileInputStream("somefile.xyz");
try {
    somethingThatMightThrowAnException();
}
finally {
    // cleanup here
    in.close();
}

Note that (in Java at least, probably also in C#) it's also possible to have a try block without a catch, but with a finally. When an exception happens in the try block, the code in the finally block is run before the exception is thrown higher up:

InputStream in = new FileInputStream("somefile.xyz");
try {
    somethingThatMightThrowAnException();
}
finally {
    // cleanup here
    in.close();
}

回复收藏 0 原文

梨涡少年 2024-09-19 23:57:57

您可能想要放置您想要执行的代码，无论 try 或 catch 块中发生什么情况。

另外，如果您正在使用多个 catch 并且您想放置一些对于所有 catch 块通用的代码，那么这将是一个放置的地方 - 但您无法确定 try 中的整个代码都已被执行。

例如：

conn c1 = new connection();
try {
    c1.dosomething();
} catch (ExceptionA exa) {
    handleexA();
    //c1.close();
} catch (ExceptionB exb) {
    handleexB();
    //c1.close();
} finally {
    c1.close();
}

You may want to put the code that you want to anyway get executed irrespective of what happens in your try or catch block.

Also if you are using multiple catch and if you want to put some code which is common for all the catch blocks this would be a place to put- but you cannot be sure that the entire code in try has been executed.

For example:

conn c1 = new connection();
try {
    c1.dosomething();
} catch (ExceptionA exa) {
    handleexA();
    //c1.close();
} catch (ExceptionB exb) {
    handleexB();
    //c1.close();
} finally {
    c1.close();
}

回复收藏 0 原文

如歌彻婉言 2024-09-19 23:57:57

最后总是会被执行，而 catch 之后的代码可能不会被执行。

回复收藏 0 原文

活泼老夫 2024-09-19 23:57:57

还在向下滚动吗？干得好！

这个问题让我一度很难过。

try
{
 int a=1;
 int b=0;
 int c=a/b;
}
catch(Exception ex)
{
 console.writeline(ex.Message);
}
finally
{
 console.writeline("Finally block");
}
console.writeline("After finally");

在上述场景中会打印什么？
是的，猜对了：

ex.Message--无论它是什么（可能尝试除以零）
最终阻止
finally 之后
<前><代码>尝试
{
整数a=1；
整数b=0；
int c=a/b;
}
捕获（异常前）
{
抛出（前）；
}
最后
{
console.writeline("终于阻塞了");
}
console.writeline("最后之后");

这会打印什么？没有什么！由于 catch 块引发了错误，因此它会引发错误。

在良好的编程结构中，您的异常将被集中，从某种意义上说，该代码将从另一层处理。为了刺激这种情况，我将嵌套尝试此代码。

try
{    
 try
    {
     int a=1;
     int b=0;
     int c=a/b;
    }
    catch(Exception ex)
    {
     throw(ex);
    }
    finally
    {
     console.writeline("Finally block")
    }
    console.writeline("After finally");
}
catch(Exception ex)
{
 console.writeline(ex.Message);
}

在这种情况下，输出将是：

Finally block
ex.Message——无论它是什么。

很明显，当您捕获异常并将其再次扔到其他层（漏斗）时，抛出后的代码不会被执行。它的作用类似于函数内的 return 的工作方式。

您现在知道为什么不在 catch 块之后的代码上关闭资源。将它们放在 finally 块中。

Still scrolling down? Here you go!

This question gave me tough time back a while.

try
{
 int a=1;
 int b=0;
 int c=a/b;
}
catch(Exception ex)
{
 console.writeline(ex.Message);
}
finally
{
 console.writeline("Finally block");
}
console.writeline("After finally");

what would be printed in the above scenario?
Yes guessed it right:

ex.Message--whatever it is (probably attempted division by zero)
Finally block

After finally

try
{
    int a=1;
    int b=0;
    int c=a/b;
}
catch(Exception ex)
{
    throw(ex);
}
finally
{
    console.writeline("Finally block");
}
console.writeline("After finally");

What would this print? Nothing! It throws an error since the catch block raised an error.

In a good programming structure, your exceptions would be funneled, in the sense that this code will be handled from another layer. To stimulate such a case i'll nested try this code.

try
{    
 try
    {
     int a=1;
     int b=0;
     int c=a/b;
    }
    catch(Exception ex)
    {
     throw(ex);
    }
    finally
    {
     console.writeline("Finally block")
    }
    console.writeline("After finally");
}
catch(Exception ex)
{
 console.writeline(ex.Message);
}

In this case the output would be:

Finally block
ex.Message--whatever it is.

It is clear that when you catch an exception and throw it again into other layers(Funneling), the code after throw does not get executed. It acts similar to just how a return inside a function works.

You now know why not to close your resources on codes after the catch block.Place them in finally block.

回复收藏 0 原文