&& is a logical AND and || is a logical OR, and both always evaluate both of their operands.


&& and || always evaluate both operands


&& and || evaluate their right operand only if absolutely necessary

Here is what's right.

Those two operators are short-circuit operators, which means they first evaluate the left operand and then only evaluate the right operand if that’s really necessary.

How do you know your students might have this misconception?

This misconception can be observed in cases where the operands cause side effects:

boolean tru() {
  return true;
boolean fls() {
  return false;

tru() || fls() // "T"   -- students claim "TF"
tru() |  fls() // "TF"

fls() && tru() // "F"   -- students claim "FT"
fls() &  tru() // "FT"

How can you build on this misconception?

Use in a common idiom

This misconception provides an opportunity to discuss the following idiom, which would cause a NullPointerException if && always evaluated its right-hand operand:

if (o!=null && o.isGood()) ...

Evaluation strategies

This misconception can also be a great segway into a discussion of the idea of evaluation strategies (a central concept in programming languages). In Java, most operators are evaluated in a strict way: they always evaluate all their operands.

// most operators:
o1 OPERATOR o2  // eval o1, eval o2
o1 & o2         // eval o1, eval o2
o1 | o2         // eval o1, eval o2
// special operators:
o1 && o2        // eval o1, maybe eval o2
o1 || o2        // eval o1, maybe eval o2
o1 ? o2 : o3    // eval o1, either eval o2 or eval o3

The two short-circuit operators, and the ternary conditional operator ?:, are evaluated in a more lazy way: while they do first evaluate their left operand (o1 above), && and || only evaluate their right operand (o2) if needed, and ?: only evaluates either o2 or o3, based on the value of o1.

Stay up-to-date

Follow us on  twitter to hear about new misconceptions.