Lesson 2.5: Compound Boolean Expressions

The Three Logical Operators (EK 2.5.A.1)

Topic 2.5 introduces the logical operators that combine boolean expressions into compound conditions. These are essential for writing realistic conditions: real programs rarely check just one thing at a time. A login system checks username AND password. A discount applies when age is under 13 OR over 65. A validation rejects input when it is NOT in the valid range.

Truth tables for all three operators

int age = 25;
boolean hasTicket = true;
boolean isMember = false;

// AND: both must be true
System.out.println(age >= 18 && hasTicket);  // true && true  = true
System.out.println(age >= 18 && isMember);   // true && false = false

// OR: at least one must be true
System.out.println(hasTicket || isMember);     // true  || false = true
System.out.println(age < 13  || age >= 65);   // false || false = false

// NOT: flip the boolean
System.out.println(!hasTicket);                // !true  = false
System.out.println(!isMember);                 // !false = true

Operator Precedence (EK 2.5.A.1)

The CED specifies the evaluation order: ! binds tightest (like unary minus), then &&, then ||. All arithmetic and relational operators evaluate before any logical operator. The full chain from highest to lowest: arithmetic → relational → ! → && → ||.

// Expression: !a || b && c   where a=false, b=true, c=false
// Step 1: evaluate ! first
//   !false = true
// Step 2: evaluate && before ||
//   b && c = true && false = false
// Step 3: evaluate ||
//   true || false = true

// With parentheses making it explicit:
(!a) || (b && c)
= true || false
= true

// Common mistake: treating || and && as same precedence
// WRONG reading: (!a || b) && c = (true || true) && false = true && false = false

Short-Circuit Evaluation (EK 2.5.A.2)

Java uses short-circuit evaluation for && and ||: if the result of the compound expression can be determined from the first operand alone, the second operand is never evaluated. This is a performance optimization that also has practical consequences when the second operand has side effects.

String name = null;

// SAFE: && short-circuits when name == null is true
// The second operand (name.length() > 0) is never reached
if (name != null && name.length() > 0) {
    System.out.println("Valid name");
}

// UNSAFE: checking length before null check
if (name.length() > 0 && name != null) {  // NullPointerException!
    System.out.println("Valid name");
}

Real-World Connection

Compound boolean expressions power virtually every real software decision. A flight booking system checks seatsAvailable > 0 && paymentValid && !flightCancelled before confirming a reservation. A video game grants a bonus when levelComplete || timeBonus > 0. A form validator rejects a password when password.length() < 8 || !containsUpperCase || !containsDigit. Short-circuit evaluation is critical for null-safety patterns that appear in virtually every production Java codebase.

Summary

• Three logical operators: ! (NOT), && (AND), || (OR). All produce boolean values. (EK 2.5.A.1)
• ! inverts a boolean. Only works on boolean operands.
• && is true only when BOTH operands are true.
• || is true when AT LEAST ONE operand is true.
• Precedence: ! first, then &&, then ||. Arithmetic and relational operators evaluate before any logical operator.
• Short-circuit (EK 2.5.A.2): && skips right side when left is false; || skips right side when left is true.
• AND narrows; OR widens. "Between 1 and 10" uses &&, not ||.

Logical Operators

Logical operators combine or modify boolean values to build compound boolean expressions.

!a        // NOT: true if a is false
a && b    // AND: true only if BOTH a and b are true
a || b    // OR:  true if a is true, b is true, or both

int age = 25;
boolean hasTicket = true;

// Both conditions must be true
if (age >= 18 && hasTicket) {
    System.out.println("Enter");
}

// Either condition suffices
if (age < 13 || age >= 65) {
    System.out.println("Discount");
}

Operator Precedence

Logical operators have a defined precedence: ! is evaluated first, then &&, then ||. Use parentheses to override precedence or improve readability.

// Without parens: && binds tighter than ||
x > 1 || x > 3 && x < 10
// Evaluated as:
x > 1 || (x > 3 && x < 10)

Short-Circuit Evaluation

Java stops evaluating a compound expression as soon as the result is determined:

// && short-circuits if first operand is false
false && anything  // second operand never evaluated

// || short-circuits if first operand is true
true || anything   // second operand never evaluated

int n = 7;
System.out.println(!(n > 5));

int a = 0;
System.out.println(a != 0 && 10 / a > 2);

int x = 5;
boolean r = x > 2 && x < 6 || x == 10;
System.out.println(r);

if (x > 0 && y > 5) {
    System.out.println("Both");
} else if (x > 0 || y > 5) {
    System.out.println("One");
} else {
    System.out.println("Neither");
}

boolean r = !p || q && !q;
System.out.println(r);