Short-Circuit Evaluation

A security guard checks two things at a building gate: your ID card and your name on the visitor list. If you have no ID card, the guard doesn't bother opening the list; the answer is already "no". Java's && and || work the same way. They stop as soon as the result is known and skip the rest. This is called short-circuit evaluation, and it's what makes checks like name != null && name.length() > 0 safe.

How && and || Decide Early

The right side is only evaluated when it could still change the answer.

Watch It Skip

This program prints a message every time a condition is actually checked:

public class ShortCircuit {
    static boolean check(String name, boolean result) {
        System.out.println("  checking " + name);
        return result;
    }
 
    public static void main(String[] args) {
        System.out.println("&& with a false left side:");
        boolean a = check("hasTicket", false) && check("seatFree", true);
        System.out.println("|| with a true left side:");
        boolean b = check("isVip", true) || check("hasPass", false);
        System.out.println("Results: " + a + " " + b);
    }
}

&& with a false left side:
  checking hasTicket
|| with a true left side:
  checking isVip
Results: false true

How it works

1. Lines 2 to 5 define a small helper method that prints its name and returns the value you give it. Methods are covered in "Methods in Java".
2. Line 9: hasTicket is false, so && already knows the answer is false. seatFree is never checked.
3. Line 11: isVip is true, so || already knows the answer is true. hasPass is never checked.

Try it yourself: change && on line 9 to &. How many lines say "checking" now?

The Classic Use: Null Checks

A reference that's null points to no object, so calling a method on it throws a NullPointerException. Short-circuiting makes this pattern safe:

public class SafeCheck {
    public static void main(String[] args) {
        String coupon = null;
        if (coupon != null && coupon.length() == 8) {
            System.out.println("Coupon looks valid");
        } else {
            System.out.println("No valid coupon");
        }
    }
}

No valid coupon

coupon != null is false, so coupon.length() never runs, and the program doesn't crash. Swap the two sides and it throws a NullPointerException.

& and |: No Shortcut

& and | on booleans give the same true/false result as && and ||, but they always evaluate both sides:

Common Mistakes

Putting the null check second. name.length() > 0 && name != null crashes when name is null, because the left side runs first.

Using & or | in conditions by accident. It compiles, but loses the protection. Use && and || for conditions.

Relying on a method call in the right side always happening. If it must always run, call it before the condition and store the result.

Interview Corner

Practice

1. Easy: For each, say whether the right side runs: false && x(), true && x(), true || x(), false || x().
2. Harder: Write a condition that checks that a String city is not null, is not empty and starts with "B", in an order that can never crash.

Key Takeaways