Boolean checking in the 'if' condition

Question

Which one is better Java coding style?

boolean status = true;
if (!status) {
    //do sth
} else {
    //do sth
}

or:

Answer 1

My personal feeling when it comes to reading

if(!status) : if not status

if(status == false) : if status is false

if you are not used to !status reading. I see no harm doing as the second way.

if you use "active" instead of status I thing if(!active) is more readable

Answer 2

Former, of course. Latter is redundant, and only goes to show that you haven't understood the concept of booleans very well.

One more suggestion: Choose a different name for your boolean variable. As per this Java style guide:

is prefix should be used for boolean variables and methods.

isSet, isVisible, isFinished, isFound, isOpen

This is the naming convention for boolean methods and variables used by Sun for the Java core packages.

Using the is prefix solves a common problem of choosing bad boolean names like status or flag. isStatus or isFlag simply doesn't fit, and the programmer is forced to chose more meaningful names.

Setter methods for boolean variables must have set prefix as in:

void setFound(boolean isFound);

There are a few alternatives to the is prefix that fits better in some situations. These are has, can and should prefixes:

boolean hasLicense();
boolean canEvaluate();
boolean shouldAbort = false;

Answer 3

The former. The latter merely adds verbosity.

Answer 4

First style is better. Though you should use better variable name

Answer 5

The first one. But just another point, the following would also make your code more readable:

if (!status) {
    // do false logic
} else {
    // do true logic
}

Note that there are extra spaces between if and the (, and also before the else statement.

EDIT

As noted by @Mudassir, if there is NO other shared code in the method using the logic, then the better style would be:

if (!status) {
    // do false logic
}

// do true logic

Answer 6

I would suggest that you do:

if (status) {
    //positive work
} else {
    // negative work
}

The == tests, while obviously redundant, also run the risk of a single = typo which would result in an assignment.