Exiting a try block using break/continue in Java

Question

In Java docs I'm reading this: The finally block always executes when the try block exits. This ensures that the finally block is executed even if an unexpected exception occurs. But finally is useful for more than just exception handling — it allows the programmer to avoid having cleanup code accidentally bypassed by a return, continue, or break.

When would you ever exit a try block with a break or continue ? The only scenarios I can think of is you are running a loop inside of a try block and you exit using a break/continue but that should just exit outside of a loop and not the try block itself right?

Answer 1

When would you ever exit a try block with a break or continue?

When you have a try inside a loop; e.g.

 for (Cat cat : cattery) {
     try {
          cat.removeFromCage();
          cat.healthCheck();
          if (cat.isPedigree()) {
              continue;
          }
          cat.spey();
     } finally {
          cat.putBackInCage();
     }
 }

OK ... so there are more elegant ways of writing that "code" ... but it is just an illustration.

The only scenarios I can think of is you are running a loop inside of a try block and you exit using a break/continue but that should just exit outside of a loop and not the try block itself right?

That is right.

---

FWIW, any piece of code that involves breaking out of a try block or returning from a catch or finally or any of the other "edge case" things should probably be simplified. The JLS specifies clearly what happens in these scenarios ... but that doesn't mean you should use them in a real program.

Answer 2

Java has labels. And labels usually used with break and continue operator. So, code:

outer: for (int i=0; i < 1; i++){
  for (int j = 0; j < 1; j++) { 
    System.out.println("j:"+j);
    continue outer;
  }
  System.out.println("i:"+i);
}

will print only "j:0"

And because break and continue are 'labeled', you can use "try" statement inside loop block, and inside that block you can try to call "continue" or "break outer_loop". But "finally" statement prevents that exit, as it described in your citation.

Answer 3

For a completely contrived example:

import java.io.*;

public class Foo {
    public static void main(String[] args) throws IOException {
        for (int i = 0; i < 10; i++) {
            File file = new File("file-" + i);
            FileWriter out = null;
            try {
                out = new FileWriter(file);
                if (file.exists()) return;
                out.write("Number " + i);
                if (i % 2 == 0) continue;
                else if (i % 3 == 0) break;
            } catch (IOException e) {
                throw new RuntimeException(e);
            } finally {
                out.close();
            }
        }
    }
}

It's perfectly natural that you might want to return, break, or continue (or throw an exception) inside a try. In this example, if the finally weren't guaranteed to execute, you'd have a resource leak.

And yes, this particular problem is solved by try-with-resource in JDK7.

Answer 4

Yes, break/continue should only affect the loop, not the try/catch/finally block. The doc is just pointing out that it is easy to accidentally miss (not execute) a block of cleanup code when trying to handle exceptions, especially with those sneaky breaks and continues that change the flow!

The finally block should always be executed, unless System.exit() is called or the JVM crashes!

Answer 5

Yes possible, Using break statement we can exit try block with help of label and without using loop.

tryLabel:
        try {
            if(true)
                break tryLabel;
            System.out.println("try");
        }catch(Exception e) {
            System.out.println("catch");
            e.printStackTrace();
        }finally{
            System.out.println("finally");
        }