Why does Java allow for labeled breaks on arbitrary statements?

Question

I just learned today that the following Java code is perfectly legal:

myBlock: {
    /* ... code ... */

    if (doneExecutingThisBlock())
        break myBlock;         


        

Answer 1

is there a good reason for this design decision?

Yes. Because it works.

In the labelled break case, the fact that you don't need to be inside a loop or switch lets you to express things that are harder to express in other ways. (Admittedly, people rarely do use labelled break this way ... but that's not a fault of the language design.)

In the unlabelled break case, the behavior is to break out of the innermost enclosing loop or switch. If it was to break out of the innermost enclosing statement, then a lot of things would be much harder to express, and many would probably require a labelled block. For example:

while (...) {
     /* ... */
     if (something) break;
     /* ... */
}

If break broke out of the innermost enclosing statement, then it wouldn't break out of the loop.

---

There is another possible reason / rationale. Remember that Java was a brand new language and a relatively early adopter of exceptions and exception handling.

Consider this:

try {
    /* ... code ... */

    if (doneExecutingThisBlock())
        throw new OuttaHere();

    /* ... more code ... */
} catch (OuttaHere e) {
    /* do nothing */
}

According to the dogma, that is bad code. You shouldn't use exceptions for "normal" flow control.

(Pragmatically, that it also very inefficient due to the overheads of exception creation and handling. Exceptions performance was improved significantly in Java 8, I think, but that was ~20 years later.)

Now imagine that you are a language designer, and you feel that you have to provide an alternative to the "exceptions as flow control" anti-pattern. The "break to label" construct does exactly that. Compare the above with the example in the question.

In hindsight, this is unnecessary. The above can be done in other ways; i.e. without labelled break. In practice this construct is used so rarely that many (maybe most) programmers don't even know it exists in Java.

Answer 2

The issue with goto is that it can jump forward, past code. A labeled break cannot do that (it can only go backwards). IIRC C++ has to deal with goto jumping past code (it is been over 17 years since I cared about that though so I am not sure I am remembering that right).

Java was designed to be used by C/C++ programmers, so many things were done to make it familiar to those developers. It is possible to do a reasonable translation from C/C++ to Java (though some things are not trivial).

It is reasonable to think that they put that into the language to give C/C++ developers a safe goto (where you can only go backwards in the code) to make it more comfortable to some programmers converting over.

I have never seen that in use, and I have rarely seen a labeled break at all in 16+ years of Java programming.

You cannot break forward:

public class Test 
{
    public static void main(final String[] argv) 
    {
        int val = 1;

        X:
        {
            if(argv.length == 0)
            {
                break X;
            }

            if(argv.length == 1)
            {
                break Y;   <--- forward break will not compile
            }
        }

        val = 0;

        Y:
        {
            Sysytem.out.println(val); <-- if forward breaks were allowed this would 
                                          print out 1 not 0.
        }
    }
}

Answer 3

Why make it so that you can only break out of certain enclosing statements using labeled breaks but not regular breaks

Consider:

while (true) {
    if (condition) {
        break;
    }
}

If the break did as you suggest, this code would perform unexpectedly. Breaks would become a lot more difficult to use.

And why allow for this behavior at all?

I don't use it, but it is a feature and allows for certain unique control-flow constructs. I'd ask you, why not allow it?

Answer 4

It is plausible that this was done for simplicity. If originally the labeled break can only break loop statements, then it should be immediately clear to language designer that the restriction isn't necessary, the semantics work the same for all statements. For the economics of the language spec, and simpler implementation of compilers, or just out of the habit towards generality, labeled break is defined for any statement, not just loop statements.

Now we can look back and judge this choice. Does it benefit programmers, by giving them extra expression power? Seems very little, the feature is rarely used. Does it cost programmers in learning and understanding? Seems so, as evidenced by this discussion.

If you could go back time and change it, would you? I can't say I would. We have a fetish for generality.

If in a parallel universe it was limited to loop statements only, there is still a chance, probably much smaller, that someone posts the question on stackoverflow: why couldn't it work on arbitrary statements?

Answer 5

Adding to Stephen C's answer, if (something) you cannot break out of a nested loop. These situations do happen in numerical algorithms. One simple example here - you cannot break out of the i-loop without the named for. Hope this helps.

public class JBreak  {

    private int brj;

    public JBreak (String arg) {
        brj = Integer.parseInt (arg);       
    }

    public void print () {
        jbreak:
        for (int i = 1 ; i < 3 ; i++) {
            for (int j = 0 ; j < 5 ; j++) {
                if ((i*j) == brj)
                    break jbreak;
                System.out.println ("i,j: " + i + "," + j);
    }}}

    public static void main (String[] args) {
        new JBreak(args[0]).print();
}}

Answer 6

The ability to leave a sequence of statements has been implemented in several programming languages before Java. Two examples:

Algol-68 had exit to terminate the execution of the smallest closed-clause (very loosely speaking, a begin ... end sequence).

BLISS had labelled BEGIN … END blocks, with a LEAVE statement to terminate execution.

Implementations with labels (as in Java) are more flexible in that they can exit nested blocks (or compound statements, or whatever you call them in your language of choice); without the label, you're limited to exiting a single "level" only.

Answering the direct question, "why" -- because it's been found to be a useful construct in other, prior, languages.