Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

Don’t Extract Everything Into a Method

DZone's Guide to

Don’t Extract Everything Into a Method

As great as clean code is, the focus on it can forgo some less popular, but still useful, language features, like break and continue statements.

· Java Zone
Free Resource

Build vs Buy a Data Quality Solution: Which is Best for You? Gain insights on a hybrid approach. Download white paper now!

Every now and then, I tweet something like this, just to piss off some clean coders:

Image title

Apart from the obvious trolling factor (why can’t I ever resist?), I do think there’s something thought-provoking in such a tweet.

First off, given how rare break and continue statements are in Java code, many people probably don’t know that you can break out of an if-else block, or any labeled block for that matter.

Secondly, we’ve been following cargo cults about clean code so much that we completely forget about some more obscure language features of our favorite languages that would be so handy in edge cases. Like these ones!

Breaking Out of Loops

Most people know how this works:

for (int i = 0;; i++)
 
    // Stop at 42
    if (i == 42)
        break;
 
    // Ignore even numbers
    else if (i % 2 == 0)
        continue;
 
    // Main action
    else
        System.out.println("i = " + i);


Of course, this code is bogus just to illustrate the syntax. A much simpler, refactored, equivalent version is this:

// Stop criteria in loop, duh
for (int i = 0; i < 42; i++)
 
    // Inverse if and else for even numbers
    if (i % 2 != 0)
        System.out.println("i = " + i);


This refactoring was obvious and trivial because the loop is so simple. But sometimes it isn’t, or sometimes the break or continue statement makes a loop just simpler to read (“simplicity”, like “beauty”, is in the eye of the beholder, of course). Parsers are the most obvious example, but also, for example, consider jOOQ’s AbstractRecord.compareTo() method, which contains this loop:

for (int i = 0; i < size(); i++) {
    final Object thisValue = get(i);
    final Object thatValue = that.get(i);
 
    if (thisValue == null && thatValue == null)
        continue;
    else if (thisValue == null)
        return 1;
    else if (thatValue == null)
        return -1;
    else {
        // ... Actually interesting comparisons
    }
}
 
// If we got through the above loop, the two records are equal
return 0;


jOOQ Records are compared with each other like SQL Records (if they are comparable, i.e. of equal degree): From the first attribute to the last.

The interesting bit here is the continue statement that skips to the next attribute if both attributes are null.

Of course, if you are a feverish hater of such explicit, goto-style control flow, you would probably refactor this to something “much better”, namely:

for (int i = 0; i < size(); i++) {
    final Object thisValue = get(i);
    final Object thatValue = that.get(i);
 
    if (!(thisValue == null && thatValue == null)) {
        if (thisValue == null)
            return 1;
        else if (thatValue == null)
            return -1;
        else {
            // ... Actually interesting comparisons
        }
    }
}
 
// If we got through the above loop, the two records are equal
return 0;


Drawbacks:

  • There’s one more level of indentation.
  • The if-else branch series is no longer “regular”, i.e. some conditions lead to quite different control flow than others.
  • This worked fine for a single continue statement, but we might complicate this loop and add a second continue statement, or better: A nested loop that also contains break or continue statements…

With loops, the choice of using break or continue is sometimes “obvious”. Refactoring the imperative programming style to something more “elegant” might take quite a while of thinking, introduce regressions, and (gasp) make the code more complex and less readable. Yes, I said it. Sometimes, imperative style is simpler (not better, just simpler).

Of course, this isn’t necessarily true in this particular example, so don’t haunt me.

Breaking Out of an If

While breaking out of loops (or continuing them from in the middle) is somewhat common in complicated loops, breaking out of an if is certainly less common. In fact, you can break out of any labeled statement in Java (label-less breaks are possible with loops only):

// No-op
label1:
break label1;
 
// More interesting, Russian Roulette:
label2: {
    System.out.println("Pulling trigger");
 
    if (Math.random() < 0.16) {
        System.out.println("Click");
        break label2;
    }
 
    System.out.println("Whew");
}


So, why not break out of an if-else?

public class FunWithBreak {
    public static void main(String[] args) {
        label:
        if (args.length > 0) {
            System.out.println("We got args!");
 
            for (String arg : args)
                if ("ignore-args".equals(arg))
                    break label;
 
            for (String arg : args)
                System.out.println("Arg : " + arg);
        }
        else {
            System.out.println("No args");
        }
 
        System.out.println("End of program");
    }
}


Now run this program from the command line:

> java FunWithBreak
No args
End of program

> java FunWithBreak a b c
We got args!
Arg : a
Arg : b
Arg : c
End of program

> java FunWithBreak a b c ignore-args
We got args!
End of program


It’s kind of neat, no? The break in the middle of the if statement. It makes sense because there’s an early abort condition for the if-block, and only for the if-block.

Alternatives

Someone responded to my original tweet that I should refactor the code and factor out a method for the if-block, which would allow for replacing the break by return. Here’s how that would work:

public class FunWithBreak {
    public static void main(String[] args) {
        if (args.length > 0)
            nameThisLater(args);
        else
            System.out.println("No args");
 
        System.out.println("End of program");
    }
 
    // TODO find a meaningful name for this method later
    private static void nameThisLater(String[] args) {
        System.out.println("We got args!");
 
        for (String arg : args)
            if ("ignore-args".equals(arg))
                return;
 
        for (String arg : args)
            System.out.println("Arg : " + arg);
    }
}


Now, that certainly looks more common, which doesn’t mean it’s better. We’ve now factored out a useless method that is called only exactly once, and that is inlined (hopefully) by the JIT to become the original code again.

The advantage is that our original main() method got a bit simpler to read (once we’ve found a meaningful name for the method), but again, simplicity is in the eye of the beholder. But the price we pay here is that we have to pass all local state as method arguments. Simple in this case (single local variable args), but that can become quite complex, especially when we have local mutable collections that need to be passed around.

Besides, others might argue that one shouldn’t return from the middle of a method. They are proponents of “single-return-statement methods”.

Sure, why not. Here’s how that would look:

public class FunWithBreak {
    public static void main(String[] args) {
        if (args.length > 0) {
            ifBlock(args);
        }
        else {
            System.out.println("No args");
        }
 
        System.out.println("End of program");
    }
 
    private static void ifBlock(String[] args) {
        System.out.println("We got args!");
 
        boolean ignoreArgs = false;
        for (String arg : args) {
            if ("ignore-args".equals(arg)) {
                ignoreArgs = true;
                break; // We need break again!
            }
        }
 
        if (!ignoreArgs)
            for (String arg : args)
                System.out.println("Arg : " + arg);
    }
}


Is it really better?

I don’t know. I’ll just stick with the original break-out-of-if.

Bonus

Surprise your coworkers with an even more unusual placement of your label. Between the if statement and the ensuing block. After all, the curly braces are just an ordinary block, not part of the if statement:

public class FunWithBreak {
    public static void main(String[] args) {
        if (args.length > 0) label: {
            System.out.println("We got args!");
 
            for (String arg : args)
                if ("ignore-args".equals(arg))
                    break label;
 
            for (String arg : args)
                System.out.println("Arg : " + arg);
        }
        else {
            System.out.println("No args");
        }
 
        System.out.println("End of program");
    }
}


Second Bonus

Now that we’ve gotten all hooked on imperative control flow… What does this print?

for (int i = 0; i < 3; i++) {
 
    hmmm:
    try {
        System.out.println("Try      : " + i);
        if (i % 2 == 0)
            break hmmm;
        else
            throw new RuntimeException("Hmmm");
    }
    finally {
        System.out.println("Finally  : " + i);
        if (i < 2)
            continue;
    }
 
    System.out.println("Loop end : " + i);
}


Solution:

Try      : 0
Finally  : 0
Try      : 1
Finally  : 1
Try      : 2
Finally  : 2
Loop end : 2


Build vs Buy a Data Quality Solution: Which is Best for You? Maintaining high quality data is essential for operational efficiency, meaningful analytics and good long-term customer relationships. But, when dealing with multiple sources of data, data quality becomes complex, so you need to know when you should build a custom data quality tools effort over canned solutions. Download our whitepaper for more insights into a hybrid approach.

Topics:
java ,clean code ,break statements ,continue statements

Published at DZone with permission of Lukas Eder, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}