Java flow control exercises — the entry grade, the library and a three-attempt ATM (and the 9.5 that came out as “Pass”)

A classmate once showed me his grade validator, very proud of it: “it works, I’ve tested it”. He had tested it with a 6. I asked him to enter a 9.5 and the program answered, without batting an eyelid: “Pass”. No error, no exception, no compiler warning. Each condition was correctly written on its own; what was wrong was the order: the first one was grade >= 5, and 9.5 is also greater than or equal to 5. In an else if chain the first true condition wins and the rest are not even looked at. You’ll see that bug with its real output in “What’s wrong here?”, and the first exercise forces you to order them properly.

Here are three Java flow control exercises, from easier to harder: the university entry grade (ranges with else if and validating before calculating), the faculty library loan (switch on a String, each case with its own braces) and an ATM with three PIN attempts without loops and one operation with switch. As in the flow control practice, there are no loops or arrays: each run does just one thing. At the end you have the exam-style quiz and the cheat sheet.

How to use this article

1. Read the statement and the expected output of each exercise. The output is real: if your program prints the same with the same data, you’re on the right track.
2. Try it without looking at anything for at least 15 minutes. If you get stuck, open the hint.
3. Before the solutions, do “What’s wrong here?”: three fragments with one bug each. Predict what they print before reading the explanation.
4. Compare your solution with the commented one. It doesn’t have to be identical: it has to give the same output with the same data and for the same reasons.

Basic level

Exercise 1 — University entry grade validator

Write GradeValidator: it asks for a university entry grade (from 0 to 14, as in Spain’s university entrance exam with the optional subjects) and rates it like this:

Then it says how far above or below the GCID cut-off grade it is, which we’ll take as 10.5 (made up), with two decimals. If the grade is outside 0-14, it warns and calculates nothing else. Finally it prints the unrounded margin with println, to see what the double really stores.

Expected output with 11,8:

=== ENTRY GRADE VALIDATOR ===
Entry grade (0-14): 11,8

--- Result ---
Rating: Excellent
You get into GCID: 1,30 above the cut-off (10,5).
Unrounded margin: 1.3000000000000007

With 15:

=== ENTRY GRADE VALIDATOR ===
Entry grade (0-14): 15
Invalid data: the entry grade goes from 0 to 14.

With 4,99:

=== ENTRY GRADE VALIDATOR ===
Entry grade (0-14): 4,99

--- Result ---
Rating: Fail
You are 5,51 short of the cut-off (10,5).
Unrounded margin: -5.51

Intermediate level

Exercise 2 — Library menu

Write Library: the faculty library handles one operation per run, chosen from a menu.

• 1. Borrow a book: asks for the member type, how many books they already have and the title. By type: student 15 days and 3 books at most; PDI (teaching and research staff) 30 days and 6 books; visitor 7 days and 1 book. If the type doesn’t exist, the title is missing or they already have the maximum, it says so; otherwise it confirms the loan.
• 2. Return a book: asks for the member type and the days late. On time, it thanks them; PDI staff pay no fine; everyone else pays 0.20 € per day up to 5 €.
• 3. See the rules.
• Any other number: “Invalid option”.

The member type is accepted in any mix of upper and lower case (PDI, pdi). The rules are made up.

Expected output for a loan and for a loan that doesn’t fit:

=== FACULTY LIBRARY ===
1. Borrow a book
2. Return a book
3. See the rules
Option: 1
Member type (student/pdi/visitor): student
Books you already have: 1
Title: Clean Code
Loan done: 'Clean Code' for 15 days (2 of 3 books).

=== FACULTY LIBRARY ===
1. Borrow a book
2. Return a book
3. See the rules
Option: 1
Member type (student/pdi/visitor): visitor
Books you already have: 1
Title: Java in Depth
You can't take any more: you already have 1 of 1.

Returns 9 days late, 40 days late (it hits the maximum) and from a PDI member typed in capitals:

=== FACULTY LIBRARY ===
1. Borrow a book
2. Return a book
3. See the rules
Option: 2
Member type (student/pdi/visitor): student
Days late: 9
Fine: 1,80 € (0.20 € per day, 5 € at most).

=== FACULTY LIBRARY ===
1. Borrow a book
2. Return a book
3. See the rules
Option: 2
Member type (student/pdi/visitor): student
Days late: 40
Fine: 5,00 € (0.20 € per day, 5 € at most).

=== FACULTY LIBRARY ===
1. Borrow a book
2. Return a book
3. See the rules
Option: 2
Member type (student/pdi/visitor): PDI
Days late: 12
Returned 12 days late: PDI staff pay no fine.

And an option that doesn’t exist:

=== FACULTY LIBRARY ===
1. Borrow a book
2. Return a book
3. See the rules
Option: 5
Invalid option: 5

Final challenge

Exercise 3 — ATM with PIN

Write AtmPin: the right PIN is 4321 and there are three attempts without using loops. After each failure it says how many attempts are left; on the third failure, “Card blocked. Call your bank.” and the program ends. With the right PIN, a menu with one operation:

• 1. Check balance (it starts at 500.00 €).
• 2. Withdraw cash: the amount must be positive and a multiple of 10, at most 600 € per operation, and no more than the balance. Check in that order.
• 3. Deposit cash: from 1 to 1000 € per deposit.

Always read lines (nextLine() + Integer.parseInt), and store the PIN as text. Expected output getting it right on the second try and withdrawing 120 €:

=== ATM ===
PIN: 1111
Wrong PIN (2 attempts left)
PIN: 4321
Correct PIN.

1. Check balance
2. Withdraw cash
3. Deposit cash
Operation: 2
Amount (multiple of 10): 120
Take 120 €. Balance: 380,00 €

Three failures:

=== ATM ===
PIN: 1111
Wrong PIN (2 attempts left)
PIN: 2222
Wrong PIN (1 attempt left)
PIN: 0000
Card blocked. Call your bank.

Without enough balance, with an amount that can’t be given in notes and with a deposit:

=== ATM ===
PIN: 4321
Correct PIN.

1. Check balance
2. Withdraw cash
3. Deposit cash
Operation: 2
Amount (multiple of 10): 550
Insufficient balance: you have 500,00 €.

=== ATM ===
PIN: 4321
Correct PIN.

1. Check balance
2. Withdraw cash
3. Deposit cash
Operation: 2
Amount (multiple of 10): 125
Invalid amount: the machine only gives 10, 20 and 50 notes.

=== ATM ===
PIN: 4321
Correct PIN.

1. Check balance
2. Withdraw cash
3. Deposit cash
Operation: 3
Amount to deposit: 200
Deposit done. Balance: 700,00 €

What’s wrong here?

Before the solutions, three fragments with one bug each: all three compile without warnings. Read each one and predict what it prints before looking at the output.

Mistake 1

public class ElseIfOrder {
    public static void main(String[] args) {
        double grade = 9.5;
        String rating;
        if (grade >= 5) {
            rating = "Pass";
        } else if (grade >= 7) {
            rating = "Good";
        } else if (grade >= 9) {
            rating = "Very good";
        } else {
            rating = "Fail";
        }
        System.out.println(grade + " → " + rating);
    }
}

What does it print with grade = 9.5? Real output:

9.5 → Pass

9.5 >= 5 is true, so it goes into the first branch and the chain ends there: the following else if are not evaluated. The diagram shows it on the grade line:

With grade >= 5 at the top, everything from 5 to 14 stays as “Pass”: the “Good” and “Very good” branches are dead code.

Fix: from highest to lowest.

public class ElseIfOrder {
    public static void main(String[] args) {
        double grade = 9.5;
        String rating;
        if (grade >= 9) {                   // from highest to lowest
            rating = "Very good";
        } else if (grade >= 7) {
            rating = "Good";
        } else if (grade >= 5) {
            rating = "Pass";
        } else {
            rating = "Fail";
        }
        System.out.println(grade + " → " + rating);
    }
}

9.5 → Very good

Mistake 2

public class LoanDays {
    public static void main(String[] args) {
        String kind = "student";
        int days = 0;
        switch (kind) {
            case "student":
                days = 15;
            case "pdi":
                days = 30;
            case "visitor":
                days = 7;
        }
        System.out.println(kind + ": " + days + " days");
    }
}

How many days does a student get? Real output:

student: 7 days

The break is missing in each case. Java enters case "student", sets days = 15, falls into case "pdi" and changes it to 30, falls into case "visitor" and leaves it at 7. The last value is the one that stays. It’s the same fall-through that added up instalments on purpose in the practice; here it wrecks the result.

Fix: the arrow switch, which also returns the value.

public class LoanDays {
    public static void main(String[] args) {
        String kind = "student";
        int days = switch (kind) {         // with arrows there is no fall-through
            case "student" -> 15;
            case "pdi" -> 30;
            case "visitor" -> 7;
            default -> 0;                  // in a switch that returns a value, default is mandatory
        };
        System.out.println(kind + ": " + days + " days");
    }
}

student: 15 days

Mistake 3

public class ValidAge {
    public static void main(String[] args) {
        int age = 150;
        if (age < 16 && age > 99) {
            System.out.println("Age out of range");
        } else {
            System.out.println("Age correct: " + age);
        }
    }
}

Does it reject 150 years? Real output:

Age correct: 150

age < 16 && age > 99 asks for the age to be below 16 and at the same time above 99: no number meets both, so the condition is always false and everything falls into the else. With 150: 150 < 16 is false, and with && Java doesn’t even look at the second part (short circuit).

Fix:

public class ValidAge {
    public static void main(String[] args) {
        int age = 150;
        if (age < 16 || age > 99) {      // it is enough for ONE of the two to fail
            System.out.println("Age out of range");
        } else {
            System.out.println("Age correct: " + age);
        }
    }
}

Age out of range

Commented solutions

Solution Exercise 1

import java.util.Scanner;

/**
 * University entry grade (0-14): check the range BEFORE calculating, and rate it
 * with else if from highest to lowest. Cut-off grade made up.
 */
public class GradeValidator {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        final double CUTOFF = 10.5;                 // GCID cut-off grade (made up)

        System.out.println("=== ENTRY GRADE VALIDATOR ===");
        System.out.print("Entry grade (0-14): ");
        double grade = sc.nextDouble();             // computer set to Spanish: typed with a comma (11,8)

        // 1. Validate first: if the data makes no sense, stop here and calculate nothing else
        if (grade < 0 || grade > 14) {
            System.out.println("Invalid data: the entry grade goes from 0 to 14.");
            return;
        }

        // 2. Rate from HIGHEST to lowest: the first true condition wins and the rest are not even looked at.
        //    That is why "grade >= 9" is enough and "grade >= 9 && grade < 11" is not needed.
        String rating;
        if (grade >= 11) {
            rating = "Excellent";
        } else if (grade >= 9) {
            rating = "Very good";
        } else if (grade >= 7) {
            rating = "Good";
        } else if (grade >= 5) {
            rating = "Pass";
        } else {
            rating = "Fail";
        }
        System.out.println();
        System.out.println("--- Result ---");
        System.out.println("Rating: " + rating);

        // 3. Margin over the cut-off: positive if you get in, negative if you fall short
        double margin = grade - CUTOFF;
        if (margin >= 0) {
            System.out.printf("You get into GCID: %.2f above the cut-off (%.1f).%n", margin, CUTOFF);
        } else {
            System.out.printf("You are %.2f short of the cut-off (%.1f).%n", -margin, CUTOFF);
        }
        // println ignores the computer's language: decimal point and every decimal the double has
        System.out.println("Unrounded margin: " + margin);
        sc.close();
    }
}

Why it’s done this way:

• Validate first and stop with return. If 15 carried on, it would come out as “Excellent” with a margin of 4.50: a result that looks right from impossible data. With the return at the start, everything after it can take for granted that the grade is between 0 and 14.
• From highest to lowest. With 11,8 the first condition (11.8 >= 11) is already true: “Excellent”. With 4,99 all four fail and it reaches the else: “Fail”. No value between 0 and 14 is left without a rating.
• String rating; with no initial value. Java checks that every branch gives it a value before it’s used. If you remove the final else, javac complains: variable rating might not have been initialized. It’s a help: it warns you there are unrated grades.
• The margin with printf and with println. 11.8 − 10.5 should be 1.3, but in binary 11.8 isn’t exact and the double stores 1.3000000000000007. printf("%.2f") rounds to two decimals and uses the computer’s comma (1,30); println shows the number as it is, with a point, because it ignores the language. With 4,99 the result is −5.51 and here it does come out clean. That’s why printf is the way to show results.
• -margin in the shortfall message. “You are -5,51 short” reads oddly; with the sign flipped, “You are 5,51 short”.

Solution Exercise 2

import java.util.Scanner;

/**
 * Faculty library: one operation per run (loan, return or rules), no arrays.
 * Loan periods, limits and fines made up.
 */
public class Library {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("=== FACULTY LIBRARY ===");
        System.out.println("1. Borrow a book");
        System.out.println("2. Return a book");
        System.out.println("3. See the rules");
        System.out.print("Option: ");
        int option = sc.nextInt();
        sc.nextLine();                             // Enter out before reading texts

        switch (option) {
            case 1: {                              // own braces: "kind" is also declared in case 2
                System.out.print("Member type (student/pdi/visitor): ");
                String kind = sc.nextLine().trim().toLowerCase();
                System.out.print("Books you already have: ");
                int has = sc.nextInt();
                sc.nextLine();
                System.out.print("Title: ");
                String title = sc.nextLine().trim();

                int days;                          // loan days
                int maxBooks;                      // books at the same time
                switch (kind) {                    // switch with String: compares with equals(), not with ==
                    case "student":
                        days = 15;
                        maxBooks = 3;
                        break;
                    case "pdi":
                        days = 30;
                        maxBooks = 6;
                        break;
                    case "visitor":
                        days = 7;
                        maxBooks = 1;
                        break;
                    default:
                        days = 0;                  // marker for "unknown kind"
                        maxBooks = 0;
                }

                if (days == 0) {
                    System.out.println("Unknown member type: " + kind);
                } else if (title.isEmpty()) {
                    System.out.println("The title is missing.");
                } else if (has >= maxBooks) {
                    System.out.println("You can't take any more: you already have " + has + " of " + maxBooks + ".");
                } else {
                    System.out.printf("Loan done: '%s' for %d days (%d of %d books).%n",
                            title, days, has + 1, maxBooks);
                }
                break;
            }
            case 2: {
                System.out.print("Member type (student/pdi/visitor): ");
                String kind = sc.nextLine().trim().toLowerCase();
                System.out.print("Days late: ");
                int delay = sc.nextInt();

                if (delay < 0) {
                    System.out.println("Invalid data.");
                } else if (delay == 0) {
                    System.out.println("Returned on time. Thank you.");
                } else if (kind.equals("pdi")) {
                    System.out.println("Returned " + delay + " days late: PDI staff pay no fine.");
                } else {
                    double fine = delay * 0.20;     // 20 cents per day...
                    if (fine > 5) {
                        fine = 5;                   // ...up to a maximum of 5 €
                    }
                    System.out.printf("Fine: %.2f € (0.20 € per day, 5 € at most).%n", fine);
                }
                break;
            }
            case 3:
                System.out.println("Students: 3 books, 15 days.");
                System.out.println("PDI: 6 books, 30 days.");
                System.out.println("Visitors: 1 book, 7 days.");
                System.out.println("Late: 0.20 € per day, 5 € at most (PDI staff don't pay).");
                break;
            default:
                System.out.println("Invalid option: " + option);
        }
        sc.close();
    }
}

Why it’s done this way:

• Own braces in case 1: { … } and case 2: { … }. The whole switch is a single block: if both cases declared String kind without braces, javac would say variable kind is already defined. With braces, each kind only lives inside its own case. Notice the break goes inside the braces, at the end.
• The inner switch gives a value to two variables. That’s why it’s classic (with break) and not an expression: a switch expression returns one value. The default sets days = 0 as a marker for “unknown type”, just like the certificate’s -1 in the practice.
• The order of the loan chain. First the type (if it doesn’t exist, maxBooks is 0 and “you already have 1 of 0” would make no sense), then the title, then the limit. With the visitor: 1 >= 1 is true, so they can’t take another one.
• has + 1 in the message. They had 1 and take another: 2 of 3.
• The fine with a cap. 9 × 0.20 = 1.80 €; 40 × 0.20 = 8.00 €, which is over 5 and stays at 5.00 €. A one-line alternative is Math.min(delay * 0.20, 5).
• PDI in capitals works because it’s lowercased when read; without toLowerCase(), "PDI".equals("pdi") would be false and the lecturer would pay a fine.

Solution Exercise 3

import java.util.Scanner;

/**
 * ATM: PIN with 3 attempts WITHOUT a loop (one if inside another) and one operation with switch.
 * Always read whole lines (nextLine + parseInt): that way there is no buffer trap.
 */
public class AtmPin {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        final String PIN = "4321";                 // String, not int: a PIN like 0420 would lose its zero
        final int LIMIT = 600;                     // euros per operation
        double balance = 500.0;
        int attempts = 3;

        System.out.println("=== ATM ===");
        System.out.print("PIN: ");
        String pin = sc.nextLine().trim();
        if (!pin.equals(PIN)) {                    // failure 1
            attempts--;
            System.out.println("Wrong PIN (" + attempts + " attempts left)");
            System.out.print("PIN: ");
            pin = sc.nextLine().trim();
            if (!pin.equals(PIN)) {                // failure 2
                attempts--;
                System.out.println("Wrong PIN (" + attempts + " attempt left)");
                System.out.print("PIN: ");
                pin = sc.nextLine().trim();
                if (!pin.equals(PIN)) {            // failure 3: that's it
                    System.out.println("Card blocked. Call your bank.");
                    return;                        // without this, the program would carry on to the menu
                }
            }
        }
        // If we get here, some attempt was right
        System.out.println("Correct PIN.");
        System.out.println();
        System.out.println("1. Check balance");
        System.out.println("2. Withdraw cash");
        System.out.println("3. Deposit cash");
        System.out.print("Operation: ");
        int op = Integer.parseInt(sc.nextLine().trim());

        switch (op) {
            case 1 -> System.out.printf("Balance: %.2f €%n", balance);
            case 2 -> {
                System.out.print("Amount (multiple of 10): ");
                int amount = Integer.parseInt(sc.nextLine().trim());
                // From the most general to the most specific: format, machine limit and, last, the balance
                if (amount <= 0 || amount % 10 != 0) {
                    System.out.println("Invalid amount: the machine only gives 10, 20 and 50 notes.");
                } else if (amount > LIMIT) {
                    System.out.println("Over the limit per operation (" + LIMIT + " €).");
                } else if (amount > balance) {
                    System.out.printf("Insufficient balance: you have %.2f €.%n", balance);
                } else {
                    balance -= amount;
                    System.out.printf("Take %d €. Balance: %.2f €%n", amount, balance);
                }
            }
            case 3 -> {
                System.out.print("Amount to deposit: ");
                int amount = Integer.parseInt(sc.nextLine().trim());
                if (amount > 0 && amount <= 1000) {
                    balance += amount;
                    System.out.printf("Deposit done. Balance: %.2f €%n", balance);
                } else {
                    System.out.println("Invalid amount (1 to 1000 € per deposit).");
                }
            }
            default -> System.out.println("Invalid operation.");
        }
        sc.close();
    }
}

Why it’s done this way:

• Three nested if statements. The second PIN is only asked for if the first one failed, and the third if both failed: each attempt goes inside the previous one. The diagram shows the paths:

• The return on blocking is essential. Without it, after the third failure the program would leave the three if statements and reach “Correct PIN.”. In the practice, the guessing game used the other style (one block after another and return on a hit); both are valid, and both are crying out for a loop.
• The PIN as a String. With int, 0420 would be read as 420 and a three-digit PIN would pass as valid. Also, comparing with equals avoids a NumberFormatException if someone types letters.
• Always reading lines. Integer.parseInt(sc.nextLine().trim()) leaves no Enter in the buffer, so the clean-up nextLine() isn’t needed anywhere.
• The order of the withdrawal checks. First the format (positive and a multiple of 10), then the machine’s limit and finally the balance. With 550: it’s a multiple of 10 and not over 600, so it reaches the third one: 550 > 500, insufficient balance. With 125: 125 % 10 is 5, not 0, and it stops at the first one.
• The sums. 500 − 120 = 380.00 €; 500 + 200 = 700.00 €.

Exam-style quiz

Now test yourself as in the exam. The FP2 Java quiz works like this: 15 questions in 15 minutes covering the whole Java syllabus, with a few from each topic. Here are the flow control ones: answer without running anything, check and read the explanation of the ones you miss. These questions also make up the bank of the FP2 theory mock exam.

int mark = 7;
if (mark >= 5) System.out.print("A");
else if (mark >= 7) System.out.print("B");
else System.out.print("C");
System.out.println();

int day = 2;
switch (day) {
    case 1: System.out.print("L");
    case 2: System.out.print("M");
    case 3: System.out.print("X"); break;
    default: System.out.print("?");
}
System.out.println();

int a = 4, b = 9;
String r = (a > b) ? "a" : (b % 2 == 0 ? "b even" : "b odd");
System.out.println(r);

String s = new String("hello");
if (s == "hello") System.out.println("equal");
else System.out.println("different");

int x = 0;
if (x != 0 && 10 / x > 1) System.out.println("big");
else System.out.println("safe");

String day = "sat";
String kind = switch (day) {
    case "sat", "sun" -> "weekend";
    default -> "weekday";
};
System.out.println(kind);

int t = 20;
if (t > 25)
    System.out.print("hot ");
    System.out.print("beach");
System.out.println();

Watch it step by step in Python Tutor

Python Tutor (pythontutor.com) runs code line by line and marks which line runs at each step. Choose Java in the drop-down and paste this program, which rates the same 9.5 with the wrong order and with the right one:

public class TutorGrade {
    public static void main(String[] args) {
        double grade = 9.5;
        String wrong;
        if (grade >= 5) {
            wrong = "Pass";
        } else if (grade >= 9) {
            wrong = "Very good";
        } else {
            wrong = "Fail";
        }
        String right;
        if (grade >= 9) {
            right = "Very good";
        } else if (grade >= 5) {
            right = "Pass";
        } else {
            right = "Fail";
        }
        System.out.println(wrong + " / " + right);
    }
}

Output:

Pass / Very good

What to watch step by step:

1. In the first chain, the arrow goes through if (grade >= 5), goes in and jumps straight to the String right; line: the else if lines are never visited.
2. In the variables panel, wrong = "Pass" appears while grade is still 9.5.
3. In the second chain, the first condition (grade >= 9) is already true: it goes in at the first one.
4. Count the steps of each chain: both stop as soon as they find a true condition. What changes is which one they find first.

Cheat sheet: Java flow control

The essentials in 30 seconds: validate the data and stop with return before calculating; in an else if chain the first true condition wins, so the most restrictive goes first; texts are compared with equals(); “out of range” is || and “in range” is &&; in a classic switch each case needs its break (or use arrows); reading lines with nextLine() + parseInt avoids the buffer trap.

Templates from the exercises:

Before handing it in, ask yourself:

1. Have I tried a value from each branch, including the limits (5, 7, 9, 11) and one out of range?
2. Are all texts compared with equals()?
3. Does each case of a classic switch end in break, except those that fall through on purpose?
4. Do I validate the data before using it (before substring, dividing or rating)?

That wraps up flow control. In the next topic, Java loops, the guessing game and the ATM stop copying their block three times: a while repeats whatever is needed.

Did this article help you? Here is how you can support SergioLearns →