Rycal · rycal.web.app · AP Computer Science A · Unit 3 of 10

Unit 3: Boolean Expressions and if Statements

Unit 3 is about making decisions in code. It covers boolean expressions and relational operators, if and if-else statements, else-if chains, compound conditions built with AND, OR, and NOT, De Morgan's laws for simplifying those conditions, and the difference between == and .equals() when comparing objects.

AP Computer Science ABoolean Expressions and if StatementsAbout 14 minutes to read

How to use this guide

Read it in order the first time because the topics stack. Boolean expressions feed the if statement, if statements grow into if-else and else-if chains, and compound conditions with De Morgan's laws are how real conditions get written and simplified. Exam questions usually show you a short code segment and ask for the output or the value of a boolean expression, so trace each example by hand as you read.

After the first read, use the trap boxes and the tables to review the distinctions that exam questions test most often. Finish with the practice questions, then complete the recall check on the last page out loud and note any items you cannot explain yet.

What this unit is worth. Unit 3 is about 15 to 17.5 percent of the AP Computer Science A exam, one of the heaviest units. Conditionals appear in almost every free-response question, and De Morgan's law plus short-circuit evaluation are reliable multiple-choice traps.

3.1 Boolean Expressions

A boolean expression is any expression that evaluates to true or false. The relational operators compare two values and produce a boolean result.

Operator	Meaning	Example (x = 7)
`==`	equal to	`x == 7` is true
`!=`	not equal to	`x != 7` is false
`<`	less than	`x < 10` is true
`>`	greater than	`x > 10` is false
`<=`	less than or equal to	`x <= 7` is true
`>=`	greater than or equal to	`x >= 8` is false

The two sides of a relational operator must be of compatible types. Comparing an int with a double is fine, but using < on two String objects is a compile error. The operators == and != work on primitives and on objects, though for objects they compare references rather than contents. That distinction is the whole of topic 3.7.

Trap. A single = assigns, a double == compares, and the compiler treats them very differently inside a condition. if (x = 5) does not compile, because the assignment produces an int and a condition must be boolean. But if (ready = true) does compile: it assigns true to ready and the condition is always true. When a condition behaves strangely, read = as "assign" and == as "compare" and check which one the code actually says.

3.2 if Statements and Control Flow

An if statement runs its body only when its condition is true. The condition must be a boolean expression. This is control flow: the condition decides which statements execute next.

int age = 16;
if (age >= 16) {
    System.out.println("You can get a license.");
}
System.out.println("Done.");

Because age >= 16 is true, both lines print. If age were 14, only "Done." would print. Curly braces group statements into one body. Without braces, only the single statement right after the if is controlled, and everything after it runs no matter what.

Trap. A semicolon immediately after the condition ends the if with an empty statement. In if (x > 10); System.out.println("big"); the word "big" prints for every value of x, because the if controls nothing and the print statement always runs. The compiler accepts it without complaint, so this one is caught only by reading carefully.

3.3 if-else Statements

An if-else statement chooses between exactly two paths. When the condition is true the if branch runs, otherwise the else branch runs. One of the two always runs, and never both.

int score = 72;
if (score >= 90) {
    System.out.println("A");
} else {
    System.out.println("Not an A");
}

The else never takes its own condition. It simply catches every case the if condition missed. That makes if-else the right tool whenever a situation splits into two mutually exclusive outcomes.

Trap. Two separate if statements are not the same as one if-else. With if (x > 0) ... if (x < 10) ... both bodies can run, since each condition is tested independently. With if (x > 0) ... else ... exactly one body runs. When you predict output, check whether the code says else or starts a fresh if.

3.4 else if Statements

An else-if chain handles more than two outcomes. The conditions are tested in order from top to bottom, the first true condition wins, and its body runs. Once a body runs, the rest of the chain is skipped. A final else catches everything the earlier conditions missed.

int n = 85;
if (n >= 90) {
    System.out.println("A");
} else if (n >= 80) {
    System.out.println("B");
} else if (n >= 70) {
    System.out.println("C");
} else {
    System.out.println("F");
}

This prints "B". Notice that n >= 80 and n >= 70 are both true for 85, but only the first true branch runs. Order matters: the conditions should go from narrowest to broadest, because a broad condition placed first swallows the cases the later conditions were meant to catch.

Trap. An else always binds to the nearest unmatched if. In nested code without braces, the indentation can lie about which if owns the else.

if (x > 0)
    if (y > 0)
        System.out.println("both positive");
else
    System.out.println("x is not positive");

Despite the indentation, the else belongs to the inner if (y > 0), not the outer one. If x is negative, the outer condition is false, the whole body is skipped, and nothing prints at all. Braces on every nested if remove the ambiguity.

3.5 Compound Boolean Expressions

Conditions can combine simpler boolean expressions with the logical operators ! (NOT), && (AND), and || (OR). The result follows the truth tables below, where a and b are any boolean expressions.

Expression	Value
`!a`	true when `a` is false, false when `a` is true
`a && b`	true only when both `a` and `b` are true
`a \|\| b`	true when at least one of `a` and `b` is true

When operators mix, ! is evaluated first, then &&, then ||. Parentheses override that order and usually make the intent clearer. For example, !a && b negates only a and then ANDs the result with b, which is not the same as !(a && b), where the ! applies to the whole AND expression.

Java evaluates && and || with short-circuit evaluation. For a && b, if a is false the result is already decided, so b is never evaluated. For a || b, if a is true, b is never evaluated. This is often used deliberately as a guard.

if (s != null && s.length() > 0) {
    System.out.println("nonempty");
}

If s is null, the left side is false and s.length() never runs, which avoids a NullPointerException. If Java evaluated both sides, that line would crash on a null string.

Trap. Exam questions love putting dangerous code on the right side of && or ||: a division by a variable that could be zero, an array access at an index that could be out of bounds, a method call on something that could be null. Before you predict a crash, evaluate the left side first. If short-circuiting kicks in, the dangerous code on the right never executes.

3.6 Equivalent Boolean Expressions

Two boolean expressions are equivalent when they agree for every possible input. De Morgan's laws give the two equivalences that come up constantly: negating an AND produces an OR of the negations, and negating an OR produces an AND of the negations.

!(a && b)  is equivalent to  !a || !b
!(a || b)  is equivalent to  !a && !b

When the ! moves across the parentheses, two things change: each part gets negated, and the operator flips. Both changes are required. Here is the same idea applied to a realistic condition.

!(age >= 13 && age <= 19)
// is equivalent to
age < 13 || age > 19

Each relational operator has a negation, which is just the operator flipped to cover the opposite cases.

Original	Negation
`x < 5`	`x >= 5`
`x > 5`	`x <= 5`
`x <= 5`	`x > 5`
`x >= 5`	`x < 5`
`x == 5`	`x != 5`
`x != 5`	`x == 5`

Trap. The classic De Morgan error is negating each part but leaving the operator alone: turning !(a && b) into !a && !b. That expression means "neither a nor b," which is the negation of a || b, not of a && b. Whenever you distribute a ! across parentheses, flip && to || and || to && as part of the same step.

3.7 Comparing Objects

For objects, == and .equals() answer different questions. The operator == tests reference equality: whether two references point to the very same object in memory. The method .equals(), for String, tests whether the contents match character for character.

String s1 = new String("java");
String s2 = new String("java");
System.out.println(s1 == s2);       // false: two different objects
System.out.println(s1.equals(s2));  // true: same contents

The rule for the exam is simple. To compare the contents of two strings, always use .equals(). Comparing strings with == sometimes appears to work, because Java reuses a single object for identical string literals, but that reuse does not apply to strings built at runtime, such as text read from user input. Code like if (input == "quit") fails exactly when it matters.

One more caution: calling .equals() on a null reference throws a NullPointerException. Writing the literal first, as in "quit".equals(input), avoids the crash when input is null. For objects other than String, the default .equals() behaves like == unless the class overrides it.

Trap. Any question that compares two String variables with == is testing whether you know it checks references. If the strings were created separately, == is false even when the text matches. Reach for .equals() for contents, and treat == on objects as a reference check.

Confusions That Cost Points

Pair	How to keep them straight
`=` vs `==` in a condition	`=` assigns and `==` compares. `if (x = 5)` does not compile; `if (b = true)` compiles but is always true. Neither is a comparison.
`==` vs `.equals()` on Strings	`==` asks whether two references point to the same object. `.equals()` asks whether the contents match. Use `.equals()` for content comparison.
`!(a && b)` vs `!a && !b`	Only De Morgan's form is equivalent: `!(a && b)` equals `!a \|\| !b`. Negating the parts without flipping the operator gives a different expression.
Short-circuit: right side runs vs skipped	With `&&`, a false left side skips the right side. With `\|\|`, a true left side skips the right side. Dangerous code on the right may never execute.
if-else vs two separate `if`s	if-else runs exactly one branch. Two separate `if`s are independent checks, and both bodies can run.
Dangling `else`	An `else` binds to the nearest unmatched `if`, not to the `if` its indentation suggests. Use braces to make the pairing explicit.

Practice Questions

Original questions written for this guide in the style of the AP exam. Answers and explanations are on the next page, so complete the questions before checking them.

1. Consider the following declarations.

int m = 6;
int n = 2;

Which of the following expressions evaluates to true?

m % n == 1
m / n != 3
m - n >= 4
m + n <= 7

2. Consider the following code segment.

int temp = 68;
if (temp > 70)
    System.out.print("hot");
if (temp > 60)
    System.out.print("warm");