2.5 Compound Boolean Expressions

1. The three logical operators

Logical operators are used with Boolean expressions 2.5.A.1. Each one produces a Boolean value.

• !a (not) is true if a is false, and false otherwise.
• a && b (and) is true if both a and b are true, and false otherwise.
• a || b (or) is true if a is true, b is true, or both are true, and false otherwise.

A truth table lists every combination of inputs:

a	b	!a	a && b	a || b
true	true	false	true	true
true	false	false	false	true
false	true	true	false	true
false	false	true	false	false

int age = 15;
boolean hasTicket = true;
System.out.println(age >= 13 && hasTicket);
System.out.println(age >= 18 || hasTicket);
System.out.println(!hasTicket);

Output:

true
true
false

An expression that uses logical operators evaluates to a Boolean value, so you can store it, print it or use it as an if condition 2.5.A.1.

2. Order of precedence

When an expression mixes logical operators, Java evaluates ! (not) first, then && (and), then || (or) 2.5.A.1. Arithmetic and relational operators are evaluated before && and ||.

boolean a = true;
boolean b = false;
boolean c = false;
System.out.println(a || b && c);
System.out.println((a || b) && c);
System.out.println(!a || c);

Output:

true
false
false

Step by step for a || b && c: first b && c is false && false, which is false. Then a || false is true || false, which is true. Parentheses change the order: (a || b) && c is true && false, which is false.

Watch out: ! binds very tightly. To negate a comparison, put the comparison in parentheses.

int x = 5;
boolean result = !x > 3;

error: bad operand type int for unary operator '!'

The fix is !(x > 3).

3. Ranges with && and ||

To check whether a value is inside a range, join two comparisons with &&. To check whether it is outside, use ||.

int hour = 22;
boolean openHours = hour >= 9 && hour <= 17;
boolean quietHours = hour < 7 || hour > 21;
System.out.println("Open: " + openHours);
System.out.println("Quiet: " + quietHours);

Output:

Open: false
Quiet: true

Watch out: hour < 7 && hour > 21 can never be true, because no number is both below 7 and above 21. This is a logic error: the code compiles, but the condition is always false.

4. Short-circuit evaluation

Short-circuit evaluation: when the first Boolean expression alone already settles the result of && or ||, Java does not evaluate the second Boolean expression at all 2.5.A.2.

• false && anything is always false, so Java skips anything.
• true || anything is always true, so Java skips anything.

Programmers use this on purpose as a safety check. Here the division only happens when it is safe:

int games = 0;
int points = 40;
if (games != 0 && points / games > 10) {
    System.out.println("High scorer");
} else {
    System.out.println("Not enough data");
}

Output:

Not enough data

games != 0 is false, so points / games is never evaluated. Swap the two sides and the division runs first:

int games = 0;
int points = 40;
if (points / games > 10 && games != 0) {
    System.out.println("High scorer");
}

Output:

Exception in thread "main" java.lang.ArithmeticException: / by zero

The same idea protects a method call on a reference that might be null:

String nickname = null;
if (nickname != null && nickname.length() > 3) {
    System.out.println("Long nickname");
} else {
    System.out.println("No long nickname");
}

Output:

No long nickname

5. Short-circuit and side effects

If the second expression calls a method that does something visible, such as printing, short-circuit evaluation means that call may not happen. Exam questions use this to test whether you really know which side runs.

public class ShortCircuitDemo {
    public static boolean isLong(String word) {
        System.out.println("Checking " + word);
        return word.length() > 5;
    }

    public static void main(String[] args) {
        boolean first = 5 > 2 || isLong("banana");
        System.out.println("first: " + first);
        boolean second = 5 < 2 || isLong("kiwi");
        System.out.println("second: " + second);
    }
}

Output:

first: true
Checking kiwi
second: false

In first, the left side is true, so isLong("banana") is never called and nothing extra is printed. In second, the left side is false, so Java must evaluate the right side: isLong("kiwi") runs, prints its line and returns false.