Conditionals

if, else if, else

public class GradeDemo {
    public static void main(String[] args) {
        int score = 84;
        char grade;

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

        System.out.println(grade);
    }
}

Output:

B

The condition in the brackets must give a boolean. Not a number, not null, not an object. In C, if (5) is legal and means true. In Java it does not compile.

Java is refusing a whole category of bug there, the classic being if (x = 5), which in C assigns 5 and is always true. In Java that line is a type error, because assignment gives back a number and if wants a boolean.

switch

When you are checking one value against many fixed options, a ladder of if statements gets noisy. switch says it directly.

public class DayType {
    public static void main(String[] args) {
        int day = 6;
        String type;

        switch (day) {
            case 6:
            case 7:
                type = "weekend";
                break;
            case 1:
                type = "monday";
                break;
            default:
                type = "midweek";
        }

        System.out.println(type);
    }
}

The value inside switch (day) is the selector. Java compares it with each case value. When it finds a match, it runs the statements under that label.

Read the control flow from top to bottom:

• case 6: and case 7: stacked together means “either of these”.
• default: catches everything else. It is optional.
• Without break, execution continues into the statements under the next label.

Branch on keyboard input

Section 2.1 showed how to read a line with Scanner. Put that value in a condition and the same compiled program can take different paths:

import java.util.Scanner;

public class AccessMessage {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("Type admin or guest: ");
        String role = input.nextLine();

        if ("admin".equals(role)) {
            System.out.println("Settings unlocked");
        } else {
            System.out.println("Read-only access");
        }
    }
}

Compile and run the program, then type admin. Run it again and type guest. The same compiled program follows a different branch because the input value changed.

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. A learner types `admin`, but the program follows the guest branch. Which three points should you check first?

   Show the answer

   First, confirm that nextLine() stored the text in the variable used by the condition. Second, compare text with "admin".equals(role), not ==. Third, check the order of the if and else if conditions so an earlier broad condition is not taking the value first.

   Print the value before the condition when you are unsure what the program received.

2. Why does `switch` refuse a `long`, when it happily accepts `byte`, `short`, `char` and `int`?

   Show the answer

   That is a rule of the Java language, not a portable conclusion about one mandatory machine layout. Classic switch selectors support char, byte, short, int, their wrappers, String and enum types. They do not support long, float, double or boolean.

   A compiler may emit a table switch, a lookup switch, or other code depending on the cases. Do not choose switch because you assume it is faster. Choose it when one selector is being matched against fixed alternatives.

3. In the old style `switch`, what happens if you forget a `break`, and why was that ever considered a good idea?

   Show the answer

   Execution carries on into the next case and keeps going until it hits a break or the end. This is called fallthrough.

   It is a bug almost every time it happens by accident, and it is silent. No warning, just extra code running.

   It was kept because of one useful shape: stacking labels so several values share one block, like case 6: case 7: return "weekend";. That works because of fallthrough.

   Modern arrow switch (case 6, 7 -> ...) gives you that shape directly and prevents accidental fallthrough. Prefer it when fallthrough is not part of the design.

Start with the warm-ups. Continue to practice exercises when the basic idea works. Challenges are optional: skip them on a first pass and return after the next lesson.

1. Warm up: one idea with close guidance.
2. Practice: combine the idea with earlier material.
3. Challenge: investigate an edge case or implementation detail.

4 exercises85 pointsabout 95 minutes

class Access {
    static String accessFor(String role)
}

public class Access {

    // Return "settings", "read-only", or "denied".
    static String accessFor(String role) {
        return ""; // TODO: write an if / else-if / else chain
    }

    public static void main(String[] args) {
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("Type admin or guest: ");
        String role = input.nextLine();
        System.out.println(accessFor(role));
    }
}

class Fall {
    static String describeBroken(int month)
    static String describeFixed(int month)
    static String describeArrow(int month)
}

public class Fall {

    // Leave this one broken. Find the missing break before you look at anything else.
    static String describeBroken(int month) {
        String season = "";
        switch (month) {
            case 12: case 1: case 2:  season = "winter"; break;
            case 3: case 4: case 5:   season = "spring";
            case 6: case 7: case 8:   season = "summer"; break;
            case 9: case 10: case 11: season = "autumn"; break;
            default: season = "not a month";
        }
        return season;
    }

    // The same thing, fixed.
    static String describeFixed(int month) { return ""; }  // TODO

    // The same again with the arrow form, which cannot fall through at all.
    static String describeArrow(int month) { return ""; }  // TODO

    public static void main(String[] args) {
        // TODO: print all three for months 1 to 13 and find where they disagree
    }
}

class Compare {
    static boolean closeEnough(double a, double b)
    static boolean closeRelative(double a, double b)
    static double addTenth()
    static boolean naiveEquals()
}

public class Compare {

    // A fixed tolerance.
    static boolean closeEnough(double a, double b) { return false; }  // TODO

    // A tolerance that scales with the size of the numbers.
    static boolean closeRelative(double a, double b) { return false; }  // TODO

    static double addTenth()      { return 0; }      // TODO: 0.1 + 0.2
    static boolean naiveEquals()  { return true; }   // TODO: 0.1 + 0.2 == 0.3

    public static void main(String[] args) {
        // TODO: print the naive comparison and the real value of 0.1 + 0.2
        // TODO: try closeEnough on 1e15 and 1e15 + 1. Predict first.
    }
}

class Status {
    static String deploymentDecision(boolean isActive, double readiness, boolean onMedicalHold, int clearanceLevel, int supplies)
}

public class Status {

    // Rules for whether a unit can be deployed:
    //   1. The unit must be active.
    //   2. Readiness must be at least 60.0
    //   3. A unit on medical hold cannot deploy, whatever its readiness.
    //   4. A unit with clearance level 5 can deploy at readiness 40.0 or more.
    //   5. A unit with zero supplies cannot deploy, no matter what.
    //
    // Return "DEPLOY", or a reason starting with "NO" that names the rule.

    static String deploymentDecision(
            boolean isActive, double readiness, boolean onMedicalHold,
            int clearanceLevel, int supplies) {
        return ""; // TODO
    }

    public static void main(String[] args) {
        System.out.println(deploymentDecision(true,  75.0, false, 3, 100));
        System.out.println(deploymentDecision(true,  45.0, false, 5, 100));
        System.out.println(deploymentDecision(true,  95.0, true,  5, 100));
        System.out.println(deploymentDecision(false, 95.0, false, 5, 100));
        System.out.println(deploymentDecision(true,  95.0, false, 5, 0));
    }
}