Relational Operators, if-else, and switch

1. Relational Operators, if-else, and switch

Title

Think Java 2e · Chapter 5 · Conditionals and Logic

Sections 5.1-5.4 · pp. 71-77

2. What you will be able to do

Objectives

This lesson follows Think Java 2e, Chapter 5 (Conditionals and Logic), Sections 5.1-5.4, pp. 71-77. Everything on these slides can be checked against those pages.

1. Write the six relational operators correctly, and say why = and == are different.

2. Write an if statement and an if-else statement, and name the condition and the branches.

3. Explain what happens when the braces are omitted, and why you should write them anyway.

4. Spot a stray semicolon after a condition and say what it does to the program.

5. Chain and nest conditionals, and say why the last branch of a chain needs no test.

6. Write a switch statement with cases, breaks and a default, and group several cases together.

• 5.1 — Relational Operators
• 5.2 — The if-else Statement
• 5.3 — Chaining and Nesting
• 5.4 — The switch Statement

3. Retrieve before you read

Warm-up

Every program you have written so far has one thing in common. Name it.

4. The chapter that makes programs react

Concept

For more complex computations, programs need to react to inputs, check conditions and generate applicable results. This chapter introduces the Java features for expressing logic and making decisions.

• 5.1 — the six relational operators, and the boolean type
• 5.2 — if and if-else, and the punctuation that goes wrong
• 5.3 — chaining and nesting several conditions
• 5.4 — the switch statement

Downey & Mayfield, Think Java, 2nd edition (Green Tea Press / O'Reilly, 2020) — Think Java 2e, Chapter 5 (Conditionals and Logic), Sections 5.1-5.4, pp. 71-77 — Chapter 5 opens on printed page 71.

5. Relational operators and boolean

Section

Section 5.1

6. Six operators that produce true or false

Concept

Java has six relational operators that test the relationship between two values. The result of any of them is one of two special values, true or false, which belong to the data type boolean — named after the mathematician George Boole, who developed an algebraic way of representing logic.

x == y     // x is equal to y
x != y     // x is not equal to y
x > y      // x is greater than y
x < y      // x is less than y
x >= y     // x is greater than or equal to y
x <= y     // x is less than or equal to y

boolean — A data type with only two possible values, true and false.

relational operator — An operator that compares two values and produces a boolean indicating the relationship between them.

You are probably familiar with these from mathematics. Notice how Java differs from the mathematical symbols: there is no single-character 'not equal' or 'greater than or equal' sign, so each is written as two characters.

7. Three ways to write these wrongly

Notation

The operators themselves are familiar. The mistakes are specific to Java and worth naming before you make them.

The = for == mistake deserves special attention. In some languages it silently compiles into an assignment; in Java it usually fails, because an assignment does not produce a boolean.

8. Evaluating a relational expression by hand

Worked example

A relational expression is evaluated the same way as any other: substitute the values, then apply the operator. What is new is that the result is a boolean.

int x = 7;
int y = 7;
System.out.println(x == y);
System.out.println(x != y);
System.out.println(x >= y);

9. What does this display?

Prediction

Relational operators on equal values.

int a = 4, b = 4;
System.out.println(a > b);
System.out.println(a >= b);

10. A boolean is a value like any other

Concept

It is easy to think of true and false as something special. They are ordinary values of an ordinary type — you can print them, and Section 5.7 will store them in variables.

The fourth row is the new one, and it is the last primitive type this book needs. Everything in this chapter is about producing boolean values and then doing something with them.

11. Using = where you meant ==

Trap

int x = 5;
if (x = 0) {              // assignment, not comparison
    System.out.println("x is zero");
}

int x = 5;
if (x == 0) {             // comparison
    System.out.println("x is zero");
}

12. Legal or not?

Definition probe

The two sides of a relational operator must be compatible.

13. Match the operator to its meaning

Matching

Four of the six.

14. Why does Java need a boolean type at all?

Explain it to yourself

Some languages use 0 and 1 instead.

15. The if-else statement

Section

Section 5.2

16. A condition decides which statements run

Concept

Conditional statements let a program check conditions and react. The simplest is the if statement: the expression in parentheses is the condition, and if it is true the statements in braces run. If it is false, execution skips over that block.

if (x > 0) {
    System.out.println("x is positive");
}

if (x % 2 == 0) {
    System.out.println("x is even");
} else {
    System.out.println("x is odd");
}

conditional statement — A statement that uses a condition to determine which statements to execute.

block — A sequence of statements surrounded by braces, generally run as the result of a condition.

branch — One of the alternative blocks after a conditional statement.

Since the condition must be either true or false, exactly one of the two branches of an if-else will run. Never both, and never neither.

17. if against if-else

Picture it

The difference is what happens when the condition is false: an if simply skips; an if-else takes the other road.

Both paths rejoin afterwards. Whatever the condition, the statement after the conditional runs — which is worth holding on to, because it is exactly what the brace mistakes on the next slides break.

18. Tracing an if-else with two different inputs

Worked example

From this chapter on, a trace needs a specific input. Run the same code twice with different values and watch the branch change.

if (x % 2 == 0) {
    System.out.println("x is even");
} else {
    System.out.println("x is odd");
}

19. Which branch runs?

Prediction

One specific input.

int x = -4;
if (x > 0) {
    System.out.println("positive");
} else {
    System.out.println("not positive");
}

20. The condition can be any boolean expression

Concept

The parentheses do not have to contain a comparison. They have to contain something whose value is a boolean — which, as Section 5.7 will show, includes a variable.

The fourth row is where Java differs from C and Python, both of which accept a number as a condition. Java insists on a boolean, which is stricter and catches the mistakes in rows four and five.

21. A semicolon after the condition

Trap

int x = 1;
if (x % 2 == 0); {          // incorrect semicolon
    System.out.println("x is even");
}

int x = 1;
if (x % 2 == 0) {
    System.out.println("x is even");
}

22. What happens with the stray semicolon?

Prediction

x is 1, which is odd.

int x = 1;
if (x % 2 == 0);
{
    System.out.println("x is even");
}

23. Write an if-else

Fill the middle

Report whether a number is negative.

24. Why must exactly one branch run?

Socratic

It sounds obvious. Say precisely why it is guaranteed.

25. Braces are optional, and you should write them

Section

Section 5.2, continued

26. Without braces, only the next statement is conditional

Concept

The braces are optional for a branch that has only one statement. That flexibility is the source of one of the most famous bugs in modern software.

if (x > 0)
    System.out.println("x is positive");
    System.out.println("x is not zero");

The indentation says both lines are conditional. Java disagrees: without braces, only the first println is part of the if statement, and the second runs no matter what.

27. What you wrote against what the compiler sees

Picture it

The two are not the same program, and only one of them is indented honestly.

This is Lesson 1b's point about misleading indentation, with real consequences attached. Java ignores whitespace, so the indentation is a claim about the code that nothing checks.

28. The goto fail bug

Worked example

Think Java points at this by name: even experienced programmers make this mistake. It shipped in Apple's SSL code in 2014 and broke certificate verification for millions of devices.

// the shape of the bug, in Java terms
if (someCheckFailed)
    goToFail();
    goToFail();     // always runs
// ... the rest of the verification, now unreachable

29. What does this print when x is -5?

Prediction

Read the braces, not the indentation.

int x = -5;
if (x > 0)
    System.out.println("A");
    System.out.println("B");

30. The rule, and the tool that enforces it

Concept

The compiler will not complain if you omit optional braces or write empty statements. Doing so is allowed by the Java language, but it often results in bugs that are difficult to find.

• Braces make adding a second statement safe — the commonest way this bug is introduced
• They make the indentation and the structure agree, so a misindented line is visible
• Checkstyle (Appendix A.5) can warn you about missing braces and empty statements automatically
• Most professional style guides require them, for exactly the reason above

It is worth being clear that this is a style rule rather than a language rule. The language permits the shorter form; experience says do not use it.

31. Adding a statement to a braceless branch

Trap

// originally, and correct:
if (x > 0)
    System.out.println("positive");

// later, someone adds a line:
if (x > 0)
    System.out.println("positive");
    System.out.println("and nonzero");   // NOT conditional

if (x > 0) {
    System.out.println("positive");
    System.out.println("and nonzero");   // inside the block
}

32. Find the three punctuation faults

Error analysis

Three separate mistakes from this section, in one fragment. Each compiles.

The general point is that Java's punctuation is unforgiving in the direction that matters least. The errors it catches are cheap; the ones it permits are expensive.

33. Which statement about braces survives?

Two truths and a lie

Four claims. Three are false.

34. Is there ever a good reason to omit the braces?

Counterexample

Argue the other side before dismissing it.

35. Chaining and nesting

Section

Section 5.3

36. Chaining: a series of else if blocks

Concept

Sometimes you want to check related conditions and choose one of several actions. One way is by chaining a series of if and else blocks.

if (x > 0) {
    System.out.println("x is positive");
} else if (x < 0) {
    System.out.println("x is negative");
} else {
    System.out.println("x is zero");
}

chaining — A way of joining several conditional statements in sequence.

Notice the second row: once the first condition is false, the second is tested. And notice the middle column of the first row — once a branch is taken, the remaining conditions are not evaluated at all.

37. Why the last branch needs no test

Notation

The final branch is simply else, not else if (x == 0). That is not laziness; it is a claim about what is left.

The reasoning here — by the time we reach this branch, we know these things are false — is worth doing explicitly whenever you write a chain. It is where off-by-one and missing-case bugs hide.

38. The same logic, nested instead of chained

Worked example

In addition to chaining you can make complex decisions by nesting one conditional inside another. Here is the previous example rewritten.

if (x > 0) {
    System.out.println("x is positive");
} else {
    if (x < 0) {
        System.out.println("x is negative");
    } else {
        System.out.println("x is zero");
    }
}

39. What does this print for x = 0?

Prediction

A three-way chain.

if (x > 0) {
    System.out.println("x is positive");
} else if (x < 0) {
    System.out.println("x is negative");
} else {
    System.out.println("x is zero");
}

40. Chaining or nesting: which to write

Concept

They can express the same logic, so the choice is about what a reader will find clearest.

The last row is worth waiting for. Nesting if (x == 0) { if (y == 0) { ... } } is exactly the case that the && operator collapses into one line — and Lesson 5b opens with it.

41. A chain of separate ifs is not a chain

Trap

if (score >= 90) { grade = "A"; }
if (score >= 80) { grade = "B"; }
if (score >= 70) { grade = "C"; }
if (score >= 0)  { grade = "D"; }

if (score >= 90) { grade = "A"; }
else if (score >= 80) { grade = "B"; }
else if (score >= 70) { grade = "C"; }
else { grade = "D"; }

42. Order these conditions correctly

Ranking

For a grading chain using else if, from the branch that must come first.

43. Chain or independent ifs?

Discrimination

The presence of else changes the meaning entirely.

44. Rewrite a nested conditional as a chain

Constraint

Practise moving between the two forms.

45. The switch statement

Section

Section 5.4

46. Many possible values of one expression

Concept

If you need to make a series of decisions, chaining else if blocks can get long and redundant. An alternative for evaluating many possible values of a single expression is the switch statement.

switch (number) {
    case 1:
        word = "one";
        break;
    case 2:
        word = "two";
        break;
    case 3:
        word = "three";
        break;
    default:
        word = "unknown";
        break;
}

The body of a switch is organised into one or more case blocks. Each case ends with a break statement, which exits the switch body. The default block is optional and runs only if none of the cases apply.

47. The chain and the switch, side by side

Picture it

Both do the same job. The switch is longer on the page and says more clearly that all the cases are testing the same expression.

The chain repeats number == on every line; the switch names it once. For three cases that hardly matters, and for the banking programs Think Java mentions — writing out numbers in long form — it matters a great deal.

48. Grouping several cases together

Worked example

Although switch statements look longer than chained else-if blocks, they are particularly useful when multiple cases can be grouped.

String food = "banana";
switch (food) {
    case "apple":
    case "banana":
    case "cherry":
        System.out.println("Fruit!");
        break;
    case "asparagus":
    case "broccoli":
    case "carrot":
        System.out.println("Vegetable!");
        break;
}

49. What does word become?

Prediction

A missing break in the first case.

int number = 1;
String word;
switch (number) {
    case 1:
        word = "one";
    case 2:
        word = "two";
        break;
    default:
        word = "unknown";
}

50. What break does, and what happens without it

Concept

The break at the end of each case is not decoration. Without it, execution falls through into the next case — which is what makes grouping work, and what causes bugs when it is unintended.

The grouping on the previous slide relies on fall-through: three case labels in a row with nothing between them all reach the same statements. That is the one common, intentional use of it.

51. A missing break

Trap

switch (number) {
    case 1:
        word = "one";
        // no break
    case 2:
        word = "two";
        break;
    default:
        word = "unknown";
}

switch (number) {
    case 1:
        word = "one";
        break;
    case 2:
        word = "two";
        break;
    case 3:
        word = "three";
        break;
    default:
        word = "unknown";
        break;
}

52. switch or chain?

Definition probe

A switch tests one expression against constant values. A chain can test anything.

53. Complete the switch

Fill the middle

Group two cases and supply a fallback.

54. What can a switch actually test?

Edge cases

Push on where the switch statement stops being usable.

55. Four ways to make a decision

Comparison

Fill the blanks to keep them apart.

The third row is the one to reach for most often. A switch is better only when you are matching exact values — it cannot express a range, which rules it out for anything involving greater-than.

56. The pattern to carry away

Pattern

Three habits from this lesson prevent nearly every conditional bug a beginner writes.

// 1. always braces, even for one statement
if (x > 0) {
    System.out.println("positive");
}

// 2. no semicolon after the condition
if (x > 0) { ... }        // not  if (x > 0);

// 3. a chain uses else; separate ifs do not
if (score >= 90) { ... }
else if (score >= 80) { ... }
else { ... }

• = is gets; == is equals.
• Exactly one branch of an if-else runs, because a boolean has exactly two values.
• Each line ends with a semicolon or a brace — never both.
• A switch matches exact values, so it can never test a range.

57. Check: which branch

Check

Work it out before you click.

int x = 0;
if (x > 0) {
    System.out.println("A");
} else if (x < 0) {
    System.out.println("B");
} else {
    System.out.println("C");
}

58. Check: the stray semicolon

Check

Work it out before you click.

int n = 3;
if (n % 2 == 0);
{
    System.out.println("even");
}

59. Check: switch fall-through

Check

Work it out before you click.

int n = 2;
switch (n) {
    case 1:
    case 2:
        System.out.println("small");
    case 3:
        System.out.println("medium");
        break;
    default:
        System.out.println("large");
}

60. goto fail, and what it cost

Real world

The missing-braces hazard is not hypothetical. It shipped in production code used by hundreds of millions of people.

61. How sure are you?

Commit first

Commit to an answer and to your confidence.

62. Explain it to someone else

Explain it

Two minutes, out loud, with the code in front of you.

63. Exit ticket

Exit ticket

One question before you close the deck.

64. Draw the whole lesson

Connect it up

One page, from memory.

65. Recap

Recap

Four sections that add decision-making, and three punctuation hazards that come with it.

• Six relational operators produce a boolean: ==, !=, >, <, >=, <= — and =< and => do not exist.
• = is assignment, == is comparison, and Java catches the confusion because a condition must be a boolean.
• An if-else runs exactly one branch; a plain if runs zero or one.
• Braces are optional for a single statement — write them anyway. The goto fail bug is what happens otherwise.
• A semicolon after a condition makes the branch control an empty statement, and it compiles.
• Chaining joins conditions with else if; each branch is reached only when the earlier ones failed.
• Nesting puts a conditional inside a branch; good indentation is essential to keep it readable.
• A switch matches one expression against exact values, each case ending with break, and grouped labels share a block.