“使用”的好处是什么；最后"；在java中尝试catch块之后？

无论是否出现异常，try-catch结束时始终执行“finally”块。 但是，try-catch之外和之后的每一行代码都会被执行。 那么，我为什么要使用finally语句呢

例如：

try {
    //code...
} catch (Exception e) {
    //code...
} finally {
    System.out.println("This line is always printed");
}
System.out.println("Also this line is always printed !! So why to use 'finally'?? ");

---

最有用的情况是当您需要释放一些资源时：

InputStream is = ...
try {
    //code...
} catch (Exception e) {
    //code...
} finally {
    is.close();
}

更一般地说，当您希望确保代码在最后执行时使用它，即使执行过程中出现异常：

long startTime = System.currentTimeMillis();
try {
    //code...
} catch (Exception e) {
    //code...
} finally {
    long endTime = System.currentTimeMillis();
    System.out.println("Operation took " + (endTime-startTime) + " ms");
}

这个

最后执行的
块始终执行的想法是，整个块后面的第一行不是这样的


如果
catch
块让一些可丢弃的内容通过
如果它自己重新抛出一个异常，这是非常频繁的
最终块的唯一目的是关闭您在try块中打开的资源。
资源可以是数据库连接、文件写入/读取等：

Connection conn= null;
try {
 conn= get the db conn;
//do some DML/DDL
}
catch(SQLException ex) {

}
finally {
conn.close();
}

假设您正在写入文件，突然它创建了一个异常，即您关闭文件的方式。然后最终帮助您，对于数据库事务最终块也有很大帮助

但是，try-catch之外和之后的每一行代码都会被执行

嗯，不总是这样。例如，我们可以抛出
Error
，它不是Exceptuon的子类型，但是可以抛出，这样它就不会被
catch（Exception e）{..}
捕获。在这种情况下，before
try
块将把控制流移出方法，相应的
最后将调用
节，但它之后的代码将不会被调用

看看这个代码

public static void main(String[] args) {
    try{
        //...
        throw new Error("something went terribly wrong");
    } catch (Exception e) {//will NOT catch Error
        e.printStackTrace();
    } finally{//this will be invoked regardless of what happens in try,              
        System.out.println("finally block");
    }

    //if Error will be thrown in above `try` it will move flow of control 
    //from this method, which will prevent it from reaching 
    //this place and executing code after this comment
    System.out.println("after finally... may not be executed");
}

finally块是防止资源泄漏的关键工具。什么时候
关闭文件或以其他方式恢复资源时，请将代码放入
最后阻塞以确保始终恢复资源

但最后，它不仅适用于异常处理，还适用于
允许程序员避免意外使用清理代码
被返回、继续或中断绕过。将清理代码放入
最后，块始终是一种良好的做法，即使没有例外情况
预料之中

更多
只有在try块中抛出的异常被catch块实际捕获，并且执行没有被return语句（例如return语句）中断的情况下，才会运行最后一个
System.out.println
（在finally块之后）

在您的示例中，finally块将始终运行，但只有在try块中没有抛出
Error
时（它不会被捕获），如果catch块中没有抛出
Throwable
且没有其他语句时，才会继续执行finally块，这将中断执行。
Aarath问题中的示例代码将捕获RuntimeException。在这种情况下，finally块后面的代码也会运行。@jarnbjo然后，程序可以抛出
错误，而不是
运行时异常
，这也是未选中的。现在你可能会说，它可以通过捕捉可丢弃的
来处理，但这真的是真正的程序工作的方式吗？如果我们开始捕获所有错误，那么我们真的不需要
finally
部分，因为我们可以在每个catch块的末尾和try-catch部分之后移动它，以防没有执行任何catch。你的问题是，你试图用一个非常狭隘的解释来解释一个通用行为，而这个解释只涉及一个非常具体的原因。有几种情况下，代码执行将不会在finally块之后继续，例如，如果在try块中抛出任何异常，并且没有使用匹配的catch块捕获（如果是运行时或未检查的异常，则完全无关），如果catch块中抛出新异常，或者代码执行被任何其他语句中断，例如try块中的return语句。@jarnbjo OP问他为什么要使用
finally
块，认为try-catch之后的所有内容都将始终执行。为了向他证明这并不总是正确的，一个简单的例子就足够了，你不认为吗？不，最好解释一下他的陈述为什么是错误的。用catch（Throwable t）代替catch（Exception e），最后一行总是会被执行。在catch块中抛出新的异常是一种常见的模式，最后，您可以在发送新异常之前清除try块中的内容。它非常方便。符号也使代码更具语义。