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

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?

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.

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"

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

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 doing it is:

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

Check the order of parenthesis.

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
}

Order of Operation is not what you need, you need boolean algebra, this includes boolean functions. Maxterms/minterms, Gray code, Karnaugh tables, diodes,transistors, logic gates, multiplexers, bitadders, flip flops... What you want is to implement boolean "logic" on computers or virtual machines. With "order of operations" you may refer something about physics like managing delays on logic gates (OR, if) nanoseconds intervals?