In Java, what are the boolean "order of operations"?

Question

Let's take a simple example of an object "Cat". I want to be sure the "not null" cat is either orange or grey.

if(cat != null && cat.getColor() == "orange" || cat.getColor() == "grey") {
//do stuff
}

I believe AND comes first, then the OR. I'm kinda fuzzy though, so here are my questions:

1) Can someone walk me through this statement so I'm sure I get what happens?

2) Also, what happens if I add parentheses; does that change the order of operations?

3) Will my order of operations change from language to language?

Answer 1

Boolean order of operations (in all languages I believe):

1. parens
2. NOT
3. AND
4. OR

So your logic above is equivalent to:

(cat != null && cat.getColor() == "orange") || cat.getColor() == "grey"

Answer 2

First, your if statement contains three main expressions:

1. cat != null
2. cat.getColor() == "orange"
3. cat.getColor() == "grey"

The first expression simply checks whether cat is not null. Its necessary otherwise the the second expression will get executed and will result in a NPE(null pointer excpetion). That's why the use of && between the first and second expression. When you use &&, if the first expression evaluates to false the second expression is never executed. Finally you check whether the cat's color is grey.

Finally note that your if statement is still wrong because if cat is null, the third expression is still executed and hence you get a null pointer exception.

The right way of foing it is:

if(cat != null && (cat.getColor() == "orange" || cat.getColor() == "grey")) { 
//do stuff 
} 

Check the order of parenthesis.

Answer 3

The expression is basically identical to:

if ( (cat != null && cat.getColor() == "orange") || cat.getColor() == "grey") {
  ...
}

The order of precedence here is that AND (&&) has higher precedence than OR (||).

You should also know that using == to test for String equality will sometimes work in Java but it is not how you should do it. You should do:

if (cat != null && ("orange".equals(cat.getColor()) || "grey".equals(cat.getColor()))) {
  ...
}

ie use the equals() methods for String comparison, not == which simply does reference equality. Reference equality for strings can be misleading. For example:

String a = new String("hello");
String b = new String("hello");
System.out.println(a == b); // false

Answer 4

The Java Tutorials has a list illustrating operator precedence. The equality operators will be evaluated first, then &&, then ||. Parentheses will be evaluated before anything else, so adding them can change the order. This is usually pretty much the same from language to language, but it's always a good idea to double check.

It's the small variations in behavior that you're not expecting that can cause you to spend an entire day debugging, so it's a good idea to put the parentheses in place so you're sure what the order of evaluation will be.

Answer 5

Yeah && is definitely evaluated before ||. But I see you are doing cat.getColor() == "orange" which might give you unexpected result. You may want to this instead :

if(cat != null && ("orange".equals(cat.getColor()) || "grey".equals(cat.getColor()))) {
    //do stuff
}