finally | 易学教程

python try-finally

阅读更多关于 python try-finally

问题 Why does the exception in foo whizz by unnoticed, but the exception in bar is raised? def foo(): try: raise Exception('foo') finally: return def bar(): try: raise Exception('bar') finally: pass foo() bar() 回答1: From the Python documentation: If the finally clause raises another exception or executes a return or break statement, the saved exception is lost. 来源： https://stackoverflow.com/questions/8574856/python-try-finally

Is there such case when in try\\finally block the finally won't be executed?

阅读更多关于 Is there such case when in try\\finally block the finally won't be executed?

I'm studying for my test in Object Oriented Programming and I was wondering if there is any case what so ever that considering the following code: try { do something } catch (someException e) { } finally { do something } the finally block will not execute? Yes. If you crash the Java VM or otherwise muck things up via native code, cause the program to terminate, or loop/wait infinitely inside the try block. Those are the only three cases which will avoid executing the finally block. If you call System.exit(0) in the try . Or make something that makes the JVM quit or hang (like a deadlock).

Why do I need to use finally to close resources?

阅读更多关于 Why do I need to use finally to close resources?

Most of the time, the only thing I see a finally block used for is something like FileInputStream f; try{ f= new FileInputStream("sample.txt"); //something that uses f and sometimes throws an exception } catch(IOException ex){ /* Handle it somehow */ } finally{ f.close(); } My question is, if f's scope ends with the enclosing block, why do we need to close it in the finally? Because garbage collection is not the same thing as resource cleanup. For example, if you have a JDBC Connection object that goes out of scope, there's no signal sent to the database server to indicate that open cursors

In Java, is the “finally” block guaranteed to be called (in the main method)?

阅读更多关于 In Java, is the “finally” block guaranteed to be called (in the main method)?

I'm a Java rookie and I was wondering, if I have the following typical Java code public class MyApp { public static void main(String[] args) { try { // do stuff } catch { // handle errors } finally { // clean up connections etc. } } } does the JVM guarantee that the finally block will always be run? To understand where I'm coming from, I'm used to C/C++ programs that might just crash if you dereference a NULL pointer and you can't have any code to be run after that. But as I understand Java and the whole GC / managed memory business in general, there's no such thing as a null pointer

java: try finally blocks execution [duplicate]

阅读更多关于 java: try finally blocks execution [duplicate]

This question already has an answer here: Does a finally block always get executed in Java? 47 answers Strange finally behaviour? 7 answers I am confused about the try-finally execution when there exists return; in the try block. In my understanding, the finally block will always be executed, i.e. before returning to the calling method. While considering the following simple code: public class TryCatchTest { public static void main(String[] args){ System.out.println(test()); } static int test(){ int x = 1; try{ return x; } finally{ x = x + 1; } } } The result printed is actually 1. Does this

Are resources closed before or after the finally?

阅读更多关于 Are resources closed before or after the finally?

问题 In Java 7's try-with-resources, I don't know which order the finally block and the auto-closing happens. What's the order? BaseResource b = new BaseResource(); // not auto-closeable; must be stop'ed try(AdvancedResource a = new AdvancedResource(b)) { } finally { b.stop(); // will this happen before or after a.close()? } 回答1: The resource gets closed before catch or finally blocks. See this tutorial. A try-with-resources statement can have catch and finally blocks just like an ordinary try

java try finally block to close stream

阅读更多关于 java try finally block to close stream

I want to close my stream in the finally block, but it throws an IOException so it seems like I have to nest another try block in my finally block in order to close the stream. Is that the right way to do it? It seems a bit clunky. Here's the code: public void read() { try { r = new BufferedReader(new InputStreamReader(address.openStream())); String inLine; while ((inLine = r.readLine()) != null) { System.out.println(inLine); } } catch (IOException readException) { readException.printStackTrace(); } finally { try { if (r!=null) r.close(); } catch (Exception e){ e.printStackTrace(); } } } It

What is the benefit to use “finally” after try-catch block in java? [closed]

阅读更多关于 What is the benefit to use “finally” after try-catch block in java? [closed]

The "finally" block is always executed when the try-catch ends, either in case of exception or not. But also every line of code outside and after the try-catch is always executed. So, why should I use the finally statement? Example: 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'?? "); Denys Séguret The most useful case is when you need to release some resources : InputStream is = ... try { //code... } catch (Exception e) { //code... } finally { is

Determine if executing in finally block due to exception being thrown

阅读更多关于 Determine if executing in finally block due to exception being thrown

问题 Is it possible to determine if code is currently executing in the context of a finally handler as a result of an exception being thrown? I'm rather fond of using the IDisposable pattern to implement entry/exit scoping functionality, but one concern with this pattern is that you might not necessarily want the end-of-scope behavior to occur if an exception occurs in the body of the using . I'd be looking for something like this: public static class MyClass { public static void MyMethod() {

final、finally、finalize 区别

阅读更多关于 final、finally、finalize 区别

原文出处： http://wenku.baidu.com/view/2d4593d0ce2f0066f533224a.htm Final 用于声明属性，方法，类，分别表示属性不可变，方法不可重写，类不可继承。 1. 属性不可变当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数中。这两个地方只能选其一，要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值。下面这段代码演示了这一点： 4. public class Bat{ 5. final PI=3.14; //在定义时便给址值 6. final int i; //因为要在构造函数中进行初始化，所以此处便不可再给值 7. final List list; //此变量也与上面的一样 8. Bat(){ 9. i=100; 10. list=new LinkedList(); 11. } 12. Bat(int ii,List l){ 13. i=ii; 14. list=l; 15. } 16. public static void main(String[]