Compound Boolean Expressions

So far, every condition you have written asks one question: is the score at least 90? Is the password equal to "open"? Real decisions are often built from several questions. A movie theater sells a teen ticket when a customer is at least 13 and at most 19. A museum lets you in free when you are under 5 or at least 65. A phone warns you when the battery is not above 20 percent. Java has three operators for combining and flipping true-or-false values like these. This chapter teaches all three, starting with the simplest: “not.”

Recall from Topic 1.2 that a boolean holds exactly one of two values, true or false, and from Topic 2.2 that a comparison such as battery > 20 produces a boolean. Sometimes the value you have is the opposite of the one you want. You have a variable that says whether it is raining, but you want to know whether it is dry. In everyday language you just say “not raining.” Java lets you do the same thing.

A logical operator is an operator whose operands are boolean values and whose result is a boolean value. The first one is the NOT operator, written ! (an exclamation mark). It goes in front of a single boolean value and produces the opposite value:

Read !isRaining aloud as “not is raining,” or more naturally, “it is not raining.” The ! takes one operand, the value right after it.

boolean isRaining = true;
boolean isDry = !isRaining;
System.out.println(isRaining);
System.out.println(isDry);
System.out.println(!isDry);

true
false
true

Now vary one thing: instead of flipping a boolean variable, flip the result of a comparison. A phone should warn you when the battery is not above 20 percent. You can write the comparison battery > 20, wrap it in parentheses, and put ! in front.

int battery = 15;
if (!(battery > 20))
{
    System.out.println("Plug in your phone.");
}
else
{
    System.out.println("Battery is fine.");
}

Plug in your phone.

int battery = 15;
if (!battery > 20)
{
    System.out.println("Plug in your phone.");
}

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

boolean lightsOn = false;
boolean dark = !lightsOn;
lightsOn = !lightsOn;
System.out.println(lightsOn);
System.out.println(dark);
System.out.println(!dark);

true
true
false

A theater sells a teen ticket to anyone from 13 through 19 years old. One comparison cannot check that: age >= 13 lets in a 40-year-old, and age <= 19 lets in a 6-year-old. The customer has to pass both tests.

With Topic 2.4 you could already do this with a nested if:

if (age >= 13)
{
    if (age <= 19)
    {
        System.out.println("Teen ticket");
    }
}

That works, but it takes two if statements and two levels of braces to say one simple thing: “13 or older, and 19 or younger.” Java lets you say it in a single condition.

The AND operator, written && (two ampersands), combines two boolean values. The result is true only when both values are true; if either one is false, the result is false. It works like a door with two locks: it opens only when both locks are open.

Now the teen check is one condition: age >= 13 && age <= 19. An expression like this, built from smaller boolean expressions joined by logical operators, is called a compound Boolean expression. However many pieces it has, it always evaluates to one boolean value, true or false, so it can go anywhere a boolean can: in an if condition, in a boolean variable, or in println.

int age = 16;
boolean isTeen = age >= 13 && age <= 19;
System.out.println(isTeen);
age = 22;
isTeen = age >= 13 && age <= 19;
System.out.println(isTeen);

true
false

Now vary the operands. The two sides of && do not have to be comparisons; any boolean values work, including boolean variables. And the result can control an if-else directly.

boolean hasLicense = true;
boolean hasCar = false;
if (hasLicense && hasCar)
{
    System.out.println("You can drive to school.");
}
else
{
    System.out.println("Take the bus.");
}

Take the bus.

int age = 16;
if (13 <= age <= 19)
{
    System.out.println("Teen ticket");
}

error: bad operand types for binary operator '<='
  first type:  boolean
  second type: int

int age = 16;
if (13 <= age && age <= 19)
{
    System.out.println("Teen ticket");
}

int temp = 68;
boolean sunny = true;
boolean picnic = sunny && temp > 60 && temp < 85;
System.out.println(picnic);
temp = 90;
picnic = sunny && temp > 60 && temp < 85;
System.out.println(picnic);

true
false

A museum lets children under 5 and adults 65 or older in for free. Here a visitor needs to pass at least one test, not both. Nobody is both under 5 and over 65, so && would let no one in free. Java needs a second way to combine conditions.

The OR operator, written || (two vertical bars; on most keyboards the bar is above the Enter key), combines two boolean values. The result is true when at least one of them is true, and false only when both are false. Think of a room with two doors: you can get in if either door is open.

Look at the first row. In everyday speech, “or” sometimes means “one or the other, but not both,” as in “soup or salad comes with your meal.” Java’s || never means that. When both sides are true, || is true.

int age = 70;
boolean freeEntry = age < 5 || age >= 65;
System.out.println(freeEntry);
age = 30;
freeEntry = age < 5 || age >= 65;
System.out.println(freeEntry);

true
false

To see the “both are true” row in action, here is a store that gives a discount to anyone with a coupon or a membership:

boolean hasCoupon = true;
boolean isMember = true;
System.out.println(hasCoupon || isMember);

This prints true. A customer with both a coupon and a membership still gets the discount; having two reasons does not cancel it out.

Now vary the operands again. The pieces of an || can be any boolean expressions, including calls to the String method equals from Topic 1.15, which returns true when two strings hold the same text.

String day = "Sun";
if (day.equals("Sat") || day.equals("Sun"))
{
    System.out.println("Weekend hours: 10 to 4");
}
else
{
    System.out.println("Weekday hours: 8 to 6");
}

Weekend hours: 10 to 4

int day = 6;
if (day == 6 || 7)
{
    System.out.println("Weekend");
}

error: bad operand types for binary operator '||'
  first type:  boolean
  second type: int

int day = 6;
if (day == 6 || day == 7)
{
    System.out.println("Weekend");
}

int age = 70;
if (age < 5 && age >= 65)
{
    System.out.println("Free entry");
}
else
{
    System.out.println("Pay full price");
}

String weather = "snow";
int temp = 40;
if (weather.equals("rain") || temp < 32)
{
    System.out.println("Stay inside.");
}
else
{
    System.out.println("Go outside.");
}

Once a condition has more than one logical operator, a question comes up that a single operator never raised. What does this mean?

a || b && c

Does Java combine a || b first and then && c? Or b && c first and then a ||? The two orders can give different answers, so Java needs a rule. You met the same problem with arithmetic in Topic 1.3: 2 + 3 * 4 is 14, not 20, because multiplication has higher precedence (it is done first) than addition.

Logical operators have their own precedence:

1. ! (NOT) first
2. && (AND) next
3. || (OR) last

So in a || b && c, the && happens before the ||, as if you had written a || (b && c). A memory hook: AND is like multiplication and OR is like addition, so AND goes first.

These operators also fit into the bigger order you already know. ! applies to the single value right after it, before any arithmetic or comparison, which is why !battery > 20 failed in 2.5.1. Arithmetic and comparisons such as <, >=, and == all happen before && and ||. That is why age >= 13 && age <= 19 works without parentheses: both comparisons become boolean values first, and only then does && combine them.

Parentheses beat everything, so whenever you want a different order, or just want the order to be obvious to a reader, add them.

Precedence tells you how an expression is grouped: which operands each operator combines, as if Java had added invisible parentheses. Once you know the grouping, you can find the value by working out the innermost groups first, as the tables below do. (In 2.5.5 you will see that Java sometimes skips part of an expression. That never changes the value; it only matters when the skipped part would have crashed.)

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

true
false

Now add ! and some comparisons, and compare ! on one value with ! on a whole parenthesized expression.

int x = 4;
boolean flag = false;
System.out.println(!flag && x > 5 || x == 4);
System.out.println(!(flag && x > 5 || x == 4));

true
false

boolean isMember = true;
int age = 30;
boolean isTuesday = false;
if (isMember || age >= 65 && isTuesday)
{
    System.out.println("Free popcorn!");
}
else
{
    System.out.println("Popcorn is $5.");
}

boolean isMember = true;
int age = 30;
boolean isTuesday = false;
if ((isMember || age >= 65) && isTuesday)
{
    System.out.println("Free popcorn!");
}
else
{
    System.out.println("Popcorn is $5.");
}

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

true
false
true

A grade program finds a student’s average by dividing the total of their scores by how many scores there are. Early in the term a new student has no scores yet, so the count is 0. From Topic 1.3, integer division by zero crashes the program with an ArithmeticException. The program should check “there is at least one score and the average is at least 80,” but the second part is exactly the part that can crash.

In Topic 2.4 you saw that an inner if is checked only when the outer if’s condition is true, so you could protect the division by nesting it inside if (count > 0). It turns out && already protects it on its own, because of how Java evaluates && and ||.

Look back at the AND table. If the left side of && is false, the result is false no matter what the right side is. Java notices this. It evaluates the left side first, and if that side alone decides the answer, it does not evaluate the right side at all. The same is true for ||: if the left side is true, the result is true no matter what, so the right side is skipped.

Skipping the right side when the left side already decides the result is called short-circuit evaluation. It is like a teacher who checks whether homework was turned in before grading it: if there is no homework, there is nothing to grade, so the second step never happens.

Usually skipping the right side only saves a little time. It matters when the right side would crash, because then a check on the left can act as a guard: a condition placed first so that the risky part runs only when it is safe.

When an expression mixes operators, the “sides” are the groups that precedence makes (2.5.4). In a || b && c, the right side of || is the whole group b && c. If a is true, Java skips that entire group.

int total = 0;
int count = 0;
if (count > 0 && total / count >= 80)
{
    System.out.println("Honor roll");
}
else
{
    System.out.println("No honor roll yet");
}

No honor roll yet

Now vary the operator. With ||, the guard is written the other way around: the left side checks for the dangerous case and is true when it happens.

int total = 0;
int count = 0;
if (count == 0 || total / count < 60)
{
    System.out.println("Check in with your teacher");
}
else
{
    System.out.println("On track");
}

Check in with your teacher

int total = 0;
int count = 0;
if (total / count >= 80 && count > 0)
{
    System.out.println("Honor roll");
}
else
{
    System.out.println("No honor roll yet");
}

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

String word = "cat";
if (word.length() > 3 && word.substring(3, 4).equals("s"))
{
    System.out.println("Fourth letter is s");
}
else
{
    System.out.println("No fourth s");
}

This program decides whether a child can ride a roller coaster. The ride is open when it is not raining and the wind is under 30 mph. A rider must be at least 48 inches tall and must be 12 or older or riding with an adult. Before reading the trace, predict the four lines of output.

public class RideCheck
{
    public static void main(String[] args)
    {
        int heightInches = 50;
        int age = 11;
        boolean withAdult = true;
        boolean isRaining = false;
        int windSpeed = 25;

        boolean rideOpen = !isRaining && windSpeed < 30;
        boolean tallEnough = heightInches >= 48;
        boolean oldEnough = age >= 12 || withAdult;

        System.out.println("Ride open: " + rideOpen);
        System.out.println("Tall enough: " + tallEnough);
        System.out.println("Old enough: " + oldEnough);

        if (!rideOpen)
        {
            System.out.println("Sorry, the ride is closed.");
        }
        else if (tallEnough && oldEnough)
        {
            System.out.println("Enjoy the ride!");
        }
        else
        {
            System.out.println("Not this time.");
        }
    }
}

Ride open: true
Tall enough: true
Old enough: true
Enjoy the ride!

boolean isRaining = true;
int windSpeed = 25;
boolean rideOpen = !isRaining && windSpeed < 30;
System.out.println("Ride open: " + rideOpen);
if (!rideOpen)
{
    System.out.println("Sorry, the ride is closed.");
}

Ride open: false
Sorry, the ride is closed.

• ! flips a boolean: !a is true exactly when a is false. To flip a comparison, wrap it in parentheses: !(battery > 20).
• a && b is true only when both sides are true; a || b is true when at least one side is true, including when both are. Every compound Boolean expression evaluates to a single boolean.
• Each side of && and || must be a complete boolean expression: write 13 <= age && age <= 19, not 13 <= age <= 19, and day == 6 || day == 7, not day == 6 || 7.
• Comparisons happen before logical operators, and among logical operators ! comes first, then &&, then ||. Use parentheses to change the order.
• Java evaluates the left side of && and || first and skips the right side when the left side decides the result (false for &&, true for ||). Put a guard on the left to protect a risky right side.

int boxes = 0;
int items = 24;
boolean ok = boxes != 0 && items / boxes > 5 || items > 20;
System.out.println(ok);

int score = 84;
int absences = 5;
boolean extraCredit = true;
String grade;
if (score >= 90 || score >= 88 && extraCredit)
{
    grade = "A";
}
else if (score >= 80 && !(absences > 3))
{
    grade = "B";
}
else if (score >= 70 || extraCredit)
{
    grade = "C";
}
else
{
    grade = "D";
}
System.out.println("Grade: " + grade);

int month = 15;
if (month >= 1 || month <= 12)
{
    System.out.println("Valid month");
}
else
{
    System.out.println("Invalid month");
}

int month = 15;
if (month >= 1 && month <= 12)
{
    System.out.println("Valid month");
}
else
{
    System.out.println("Invalid month");
}

if (count > 0)
{
    if (total / count > 10)
    {
        System.out.println("High average");
    }
}

if (count > 0 && total / count > 10)
{
    System.out.println("High average");
}

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can use ! to flip a boolean value or a comparison in parentheses. Reread
• I can use && to require two conditions and write a range check correctly. Reread
• I can use || to accept either condition, and I know it is true when both sides are true. Reread
• I can evaluate an expression that mixes !, &&, and || in the right order, and use parentheses to change it. Reread
• I can explain when Java skips the right side of && or || and use a guard to prevent a crash. Reread