By default, a Java program runs from the first statement of main to the last, one line after another. That is enough for a Hello World, but no real program is a straight line. A banking app must ask "is the balance sufficient?" before allowing a withdrawal. A railway booking system must loop over every passenger in a group. A grading program must map a score to a letter grade. All of these need control flow — the statements that decide which code runs and how many times it runs.

Java gives you three families of control-flow statements:

• Conditionals — if, else if, else and the ternary operator ? : choose between branches based on a boolean condition.
• Switch — the classic switch statement (since Java 1.0) and the modern switch expression with arrow labels and yield (final in Java 14), extended by pattern matching for switch (final in Java 21) select one branch out of many based on a value.
• Loops — for, the enhanced for (for-each), while and do-while repeat a block, while break, continue and labels fine-tune the repetition.

Why spend a whole lecture on this? Three reasons. First, control flow is where most beginner bugs live: off-by-one errors, missing break in a switch, infinite loops, and conditions that use = where == was intended. Second, every Java interview for freshers — at TCS, Infosys, Wipro, Capgemini, Accenture and product start-ups alike — includes at least one loop-based problem such as printing a pyramid pattern, reversing a number or checking a prime. Third, the modern switch syntax is one of the most visible changes in Java since Java 8, and knowing the difference between a switch statement and a switch expression is now a standard interview question.

In the previous lecture you learned variables, data types, operators and casting. Those are the raw materials; in this lecture we use them to make decisions and repeat work. Every example is complete and compilable with any JDK 21 or JDK 25 installation, and version-specific features are labelled so you know exactly what works where.

The if statement is the simplest decision-maker. It evaluates a condition that must be of type boolean and runs the following block only when that condition is true. Unlike C or JavaScript, Java does not treat 0, null or an empty string as "falsy": writing if (count) where count is an int is a compile-time error. This strictness is a feature — it catches the classic mistake if (x = 5) (assignment instead of comparison) at compile time, because the expression x = 5 has type int, not boolean.

The full form is an if / else-if / else ladder. Java evaluates the conditions top to bottom and runs the first block whose condition is true; all remaining branches are skipped, even if their conditions would also be true. The final else (optional) is the catch-all. Because of this top-to-bottom rule, order matters: when checking score ranges, test the highest range first or every score will match the lowest range.

Three style rules will save you from real bugs:

• Always use braces, even for a single statement. Java allows if (x > 0) System.out.println("positive"); without braces, but when someone later adds a second line, it silently runs outside the if. Google, Oracle and most Indian IT companies' coding standards mandate braces.
• Put the most likely or cheapest condition first in an else-if ladder when the branches are mutually exclusive — it makes the code both faster and easier to read.
• Prefer else if over a series of separate if statements when only one branch should run. Separate ifs are evaluated independently and several can execute.

The example below implements an Indian income-tax-style slab check and a simple login check. Notice how the ladder tests the higher thresholds first and how the else handles everything that falls through.

An if inside another if is a nested condition. Nesting is natural when a second decision only makes sense after the first one passes — for example, "if the user is logged in, then if the balance is sufficient, allow the withdrawal". Two or three levels of nesting are fine; beyond that the code becomes an "arrow" that is hard to read and test. There are three standard tools for flattening deep nesting:

• Combine conditions with logical operators. && (AND), || (OR) and ! (NOT) let you write if (loggedIn && balance >= amount) instead of two nested ifs. Java's && and || are short-circuit operators: in a != null && a.length() > 0, the right side is never evaluated when a is null, which prevents a NullPointerException. The order of the operands therefore matters.
• Use guard clauses. Check the failure conditions first and return (or throw) immediately, so the "happy path" stays at the top indentation level. This is the style used in most professional Java code bases.
• Extract a method with a descriptive name such as isEligibleForLoan(applicant) when a condition grows beyond one line.

The ternary (conditional) operator condition ? valueIfTrue : valueIfFalse is a compact expression form of if/else that produces a value. It is ideal for simple assignments like String status = age >= 18 ? "Adult" : "Minor";. Do not nest ternaries more than one level deep, and never use a ternary for side effects (printing, calling methods) — use if for that. Note the dangling else rule as well: an else always pairs with the nearest unmatched if, which is another reason to always use braces.

When you need to compare one value against many constants, a long else-if ladder becomes noisy. The classic switch statement (available since Java 1.0) compares a selector expression against a list of case labels and jumps directly to the matching one. The selector can be a byte, short, char, int, their wrapper classes, an enum (Java 5) or a String (Java 7). Classic switch does not accept long, float, double or boolean.

The most important thing to understand about the classic form is fall-through. After a matching case label, execution continues downward through every following case until it hits a break or the end of the switch. This was inherited from C, and it is responsible for an enormous number of bugs: forget one break and your "Tuesday" branch also prints "Wednesday". Occasionally fall-through is used deliberately to group labels (case 1: case 7: → both weekend), but the intention is invisible to readers.

Other rules of the classic switch:

• case labels must be compile-time constants (literals, final variables, enum constants) and must be unique.
• default is optional and can appear anywhere, though convention puts it last.
• Since the classic switch is a statement, it does not produce a value; you must assign a variable inside each branch, which makes it easy to forget one.
• If the selector is a String or wrapper and its value is null, the classic switch throws a NullPointerException (Java 21 added case null for the modern form, covered in section 6).

The example shows a day-number-to-name converter with a deliberately missing break so you can see fall-through in action.

Switch expressions were previewed in Java 12 and 13 and became a final, standard feature in Java 14 (JEP 361). They fix every pain point of the classic form at once:

• Arrow labels case X -> run exactly one branch and never fall through. No break needed.
• Multiple labels per case are written with commas: case SATURDAY, SUNDAY -> "Weekend".
• The switch can be used as an expression that returns a value, so you write String name = switch (day) { ... }; and assign once.
• When used as an expression, the switch must be exhaustive: every possible value must be covered. For int or String selectors that means a default branch is mandatory; for an enum, listing every constant is enough and the compiler will complain if you miss one. This turns a whole category of runtime bugs into compile errors.
• When a branch needs several statements, write a block { ... } and produce the result with the yield keyword. yield is a contextual keyword: it is only special inside a switch, so existing variables named yield keep compiling.

You can also use arrow labels in a switch statement (one that does not return a value) purely to avoid fall-through — the right side is then a statement or block. And the old colon form can be used inside a switch expression with yield instead of break, but mixing arrow and colon labels inside the same switch is a compile error. The recommended modern style, used throughout Spring and most new Java code, is: arrow labels everywhere, switch expressions whenever you need a value. Compare the day-name example from the previous section — it shrinks from 25 lines to 7 and cannot fall through.

Java 21 (September 2023, LTS) finalized pattern matching for switch (JEP 441) together with record patterns (JEP 440). Together they turn switch from a constant-comparison tool into a full type-dispatch tool. The selector may now be any reference type, and case labels may be type patterns such as case Integer i -> that both test the type and bind a variable in one step. This replaces chains of instanceof checks and casts.

The key additions, all final in Java 21 and therefore safe to use in production:

• Type patterns: case String s -> s.length(). The variable s is in scope only in that branch.
• Guards with when: case Integer i when i > 0 -> "positive" adds a boolean condition to a pattern. Guards are checked in order, so put the specific guarded case before the general one.
• case null: for the first time a switch can handle a null selector instead of throwing NullPointerException. You can also write case null, default -> to treat null and everything unmatched together.
• Exhaustiveness and dominance checks: a pattern switch must cover all possibilities (use default or a sealed hierarchy), and a case that can never match because an earlier case already covers it (for example case Object o placed before case String s) is a compile error. The compiler enforces the order for you.
• Record patterns: case Point(int x, int y) -> deconstructs a record directly in the label.

Two version notes you should state precisely in interviews. First, this feature is not available in Java 17; Java 17 only has pattern matching for instanceof (Java 16). Second, primitive type patterns in switch (allowing switch on long, double or boolean with patterns, JEP 455 → JEP 507) are still a preview feature in Java 25 — they are not final, require --enable-preview, and must not be used in production code. Classic constant switches on long, float, double and boolean therefore remain a compile error in standard Java 25.

The for loop is the loop you reach for when you know, or can compute, how many times the body should run. Its header has three parts separated by semicolons: initialization (runs once, before the loop), condition (checked before every iteration; the loop ends when it is false) and update (runs after each iteration). The sequence is: init → check → body → update → check → body → update → ... → check fails → exit.

Important details that interviewers probe:

• A variable declared in the initialization (int i = 0) is scoped to the loop. It does not exist after the closing brace, so you can reuse the name i in the next loop.
• The condition is checked before the first iteration, so a for loop can run zero times (for example for (int i = 5; i < 3; i++)).
• All three parts are optional. for (;;) is a legal infinite loop that must be exited with break or return.
• The initialization and update parts may contain several comma-separated expressions of the same type: for (int i = 0, j = n - 1; i < j; i++, j--) walks inward from both ends, which is the standard way to check a palindrome or reverse an array in place.
• The step does not have to be ++. Use i += 2 for even numbers, i-- to count down, or i *= 2 for powers of two.
• Nested for loops run the inner loop completely for every iteration of the outer loop. Two nested loops over n items execute the inner body n × n times — this is the O(n²) you will meet in data-structure interviews.

A note on performance: the JVM's JIT compiler optimizes simple counted loops extremely well, so there is no need for tricks like caching array.length in a variable; write the clear version.

Java 5 introduced the enhanced for loop, usually called for-each, with the syntax for (Type element : collectionOrArray). Read the colon as "in": "for each element in collection". It iterates over every element of an array or any object that implements Iterable (all List, Set and Queue implementations, but not Map directly — iterate over map.entrySet(), keySet() or values()).

Use the enhanced for loop whenever you simply need every element, in order, without the index. It is shorter, cannot produce an ArrayIndexOutOfBoundsException, and expresses intent clearly. It is the default choice in professional code; the classic indexed for loop is reserved for cases where you genuinely need the index.

Limitations you must know:

• No index. If you need the position (to print "item 3 of 10", or to compare adjacent elements), use the classic for loop.
• The loop variable is a copy. For an int[], assigning element = 0 inside the loop does not change the array. For an object array or list, you can call methods that mutate the object (student.setMarks(90)) but reassigning the variable does nothing to the collection.
• You cannot add or remove elements of the collection you are iterating. Doing so on an ArrayList throws ConcurrentModificationException on the next iteration. Use an explicit Iterator with iterator.remove(), or the removeIf method, instead.
• It always goes forward from the first element. To iterate backwards or skip elements, use a classic loop.

Since Java 10 you can declare the loop variable with var (for (var city : cities)), which is handy for long generic types like Map.Entry<String, List<Integer>>.

A while loop repeats its body as long as a condition stays true, and it checks that condition before every iteration. Use it when you do not know the number of iterations in advance: reading input until the user types "quit", retrying a network call until it succeeds, or stripping digits off a number until nothing is left. Any for loop can be rewritten as a while loop and vice versa; choose the one that reads most naturally. The rule of thumb used in code reviews is: counted repetition → for; condition-driven repetition → while.

Because the condition is tested first, a while loop may run zero times. You are responsible for making sure something inside the body eventually makes the condition false; otherwise you have an infinite loop — the single most common beginner bug with while. Always ask: "which statement in the body changes the variables used in the condition?"

A do-while loop moves the check to the end: the body runs at least once, and then the condition decides whether to repeat. This is exactly what menu-driven programs need — show the menu, read the choice, and keep going until the user picks "Exit". It is also the natural fit for input validation ("ask for a number between 1 and 10; ask again if it is out of range"). Note the semicolon after while (condition) in a do-while — forgetting it is a compile error, and adding one after a normal while (condition); creates an empty infinite loop.

Both loops work with break (exit immediately) and continue (skip to the next check), which the next section covers in detail.

Inside any loop, two statements change the normal flow:

• break terminates the innermost enclosing loop (or switch) immediately. Execution continues with the first statement after that loop. Use it when you have found what you were searching for and further iterations are pointless — this is also an optimization, because a linear search over a million records should stop at the first hit.
• continue skips the rest of the current iteration and jumps to the next one: in a for loop it runs the update part and then the condition; in a while loop it goes straight to the condition. Use it to skip invalid or irrelevant items without wrapping the whole body in an if.

Both statements only affect one level of loop. In nested loops, break leaves just the inner loop and the outer loop continues. When you need to escape several levels at once, Java provides labeled statements: write an identifier followed by a colon before the outer loop (outer:), then use break outer; or continue outer;. This is far cleaner than the alternatives (boolean flags checked at every level, or throwing an exception for control flow). Labeled breaks are common in matrix searches — "find the first cell equal to the target and stop both loops".

Two cautions. First, break inside a switch that is itself inside a loop exits only the switch, not the loop; use a label if you need to leave the loop from inside the switch. Second, labels are not goto: you cannot jump to arbitrary places, only break out of or continue a labeled enclosing loop, so they stay structured and readable. Use them sparingly, and prefer extracting the nested loops into a method that simply returns when you can.

Most loop code in real projects and in interviews is a variation of a dozen patterns. Learn them as building blocks and you will rarely be stuck on a loop problem again:

• Accumulate — start with an identity value (0 for sum, 1 for product, empty string or StringBuilder for concatenation) and fold each element into it.
• Track the best so far — initialise max with the first element (not with 0, which fails for all-negative data) and update it when a larger value appears. Keep the index too if you need "which" element.
• Count matches — a counter incremented inside an if.
• Search with early exit — break or return on the first match; return a sentinel like -1 when nothing matches.
• Digit processing — n % 10 extracts the last digit, n / 10 removes it; reverse a number, sum digits, count digits, check an Armstrong number.
• Reverse in place — two indices moving toward each other, swapping elements.
• Prime check — test divisors from 2 to sqrt(n) only; one hit means not prime.
• Fibonacci / running state — keep two variables and shift them each iteration.
• Nested loop over pairs — for i, for j = i + 1 visits every unordered pair exactly once (duplicate detection, bubble sort).
• Sentinel-controlled input — read until a special value like -1 or "quit".

The program below implements the most-asked ones with expected outputs in comments. Type them out yourself; muscle memory for these patterns is what makes a 30-minute coding round comfortable. In later lectures the Streams API will give you a declarative way to write several of these (sum(), max(), filter().count()), but interviewers still expect you to write the loop version on a whiteboard.

Pattern printing questions are a rite of passage in Indian campus placements and first-round interviews at service companies. They are not about stars; they test whether you can translate a picture into nested loops, reason about rows and columns, and handle spaces correctly. Every pattern follows the same recipe:

1. The outer loop is the row. Count the rows in the picture: that is the outer loop's range (i = 1..n).
2. Find the formula for each row. Ask: how many spaces come first on row i? How many symbols? What value is printed at column j? Write those as expressions of i, j and n. For a right triangle, row i has i stars. For a centred pyramid of height n, row i has n - i leading spaces and 2i - 1 stars.
3. One inner loop per segment. Spaces loop, then symbols loop (sometimes a third loop for the decreasing half of a number pattern).
4. End the row with println(). Inside the inner loops use print, never println.
5. Trace for n = 3 by hand before running. Most mistakes are off-by-one in the ranges.

Helpful tools: " ".repeat(k) (Java 11) prints k spaces without an extra loop, and (char) ('A' + j) converts a column index to a letter for alphabet patterns. For an inverted shape, run the outer loop from n down to 1 or replace i with n - i + 1 in the formulas. For a diamond, print a pyramid of height n followed by an inverted pyramid of height n - 1. For Floyd's triangle, keep a running counter that is printed and incremented rather than deriving the value from i and j.

The program below prints the six patterns that appear most often: right triangle, inverted triangle, centred pyramid, diamond, Floyd's triangle and the number pyramid (1 / 1 2 1 / 1 2 3 2 1). Compare each loop header against the output in the comments.

Control flow is not an academic topic — it is the skeleton of every service you will write. Here is how each construct shows up in production code, so you can recognise good usage when you read Spring Boot projects on GitHub or at work:

• Validation with guard clauses. A REST controller or service method typically begins with a stack of if (...) throw new IllegalArgumentException(...) lines. Flat guard clauses are preferred over nested ifs because they keep the business logic un-indented and make each rule testable.
• State machines with switch expressions. Order processing (CREATED → PAID → SHIPPED → DELIVERED), payment status handling and workflow engines use switch over an enum to decide the next state. Because an enum switch expression is exhaustive, adding a new state like REFUNDED makes the compiler flag every switch that has not handled it — a huge safety net in large code bases.
• Dispatching on message types with pattern matching. Kafka consumers and event handlers that receive a sealed Event hierarchy use Java 21 pattern switch: case OrderPlaced op -> ..., case PaymentFailed pf -> .... This replaces fragile instanceof chains.
• Batch processing loops. Nightly jobs iterate over thousands of records with an enhanced for loop, continue past rows that fail validation (logging them), and break when a hard limit or deadline is hit.
• Retry with backoff. A while (attempt < maxAttempts) or do-while loop wraps a network call, sleeping between attempts; resilience libraries such as Resilience4j do this internally.
• Pagination. "Fetch a page, process it, fetch the next page until the page is empty" is a do-while loop by nature: you always fetch at least once.
• Rate and slab calculations. GST slabs, electricity tariffs, income-tax brackets and shipping charges by weight are if-else ladders or switch expressions. Writing them with the highest threshold first and covering the default is exactly the ordering discipline from section 2.
• Console tools and CLIs. Internal admin tools, migration scripts and interview take-home assignments use a do-while menu loop with a switch over the user's choice — the structure you will build in the hands-on exercise.

One production rule above all: keep loop bodies small and give them a name. If the body of a loop is longer than about 15 lines, extract it into a method such as processOrder(order). The loop then reads like a sentence, and the method can be unit-tested with JUnit 5 in isolation.

These are the mistakes that appear again and again in beginner code, code reviews and failed interview submissions. Each one comes with the fix.

• Missing break in a classic switch. Symptom: several branches run. Fix: add break, or better, switch to arrow labels (case 1 -> ...) which never fall through.
• Comparing strings with ==. if (city == "Pune") compares references and is often false even when the text matches (for example when the value came from user input). Fix: city.equals("Pune") or "Pune".equals(city) (null-safe), or use a switch on the String, which uses equals internally.
• Off-by-one errors. for (int i = 0; i <= arr.length; i++) throws ArrayIndexOutOfBoundsException on the last iteration. Fix: use < with zero-based indices and <= only when counting from 1. Trace the first and last iteration by hand.
• Infinite loops. The condition variable is never updated (while (i < 10) { System.out.println(i); }) or is updated in the wrong direction. Fix: identify the statement that moves the loop toward termination and make sure it runs on every path, including after a continue.
• Floating-point loop counters. for (double d = 0; d != 1.0; d += 0.1) never terminates because 0.1 is not exactly representable and d skips over 1.0. Fix: loop with an int counter and compute the double inside, or use < rather than !=.
• Integer overflow in a counter. for (byte b = 0; b < 200; b++) loops forever because a byte wraps from 127 to -128 and never reaches 200. Fix: use int, and use long for sums that may exceed about 2.1 billion.
• Semicolon after the loop header. for (int i = 0; i < 5; i++); followed by a block runs the block only once; while (cond); is an infinite empty loop. Fix: never put ; directly after for/while/if headers; modern IDEs warn about this.
• Modifying a list inside an enhanced for loop. Throws ConcurrentModificationException. Fix: removeIf, an explicit Iterator, or collect items to remove in a separate list first.
• Non-exhaustive switch expression. Compile error "the switch expression does not cover all possible input values". Fix: add a default for int/String selectors; for enums, list every constant (preferable, because the compiler then guards future additions).
• Mixing arrow and colon labels in the same switch, or using break with a value inside a switch expression. Fix: use yield to produce a value from a block, and pick one label style per switch.
• Wrong else if order. Testing marks >= 40 before marks >= 90 makes every passing student a "C". Fix: order ranges from most specific or highest to lowest.
• Unreachable code after break or continue. Java reports a compile error, not a warning. Fix: remove the dead statements.

What is the difference between a switch statement and a switch expression in Java?

A switch statement (Java 1.0) executes code but produces no value, uses colon labels and falls through between cases unless you write break. A switch expression (final in Java 14, JEP 361) produces a value that you can assign or return, uses arrow labels (case X ->) that never fall through, allows comma-separated labels, and must be exhaustive. Use yield inside a block branch to return its value.

Which Java version introduced switch expressions, and which added pattern matching for switch?

Switch expressions were previewed in Java 12 and 13 and became final in Java 14. Pattern matching for switch (type patterns, guards with when, case null) and record patterns became final in Java 21. Neither is available in Java 8 or 11; Java 17 has switch expressions but not pattern matching for switch.

When should I use a while loop instead of a for loop in Java?

Use for when the number of iterations is known or derived from a size (arrays, "n times"). Use while when the loop is driven by a condition whose end is unknown in advance, such as reading input until a sentinel, retrying until success or reducing a number until it reaches zero. Use do-while when the body must run at least once, like a menu or an input prompt.

What is the difference between break and continue in Java?

break exits the innermost loop (or switch) entirely and resumes after it. continue abandons only the current iteration and jumps to the next condition check (running the update part of a for loop first). Both affect one level unless you use a labeled statement such as break outer;.

Can we use a switch on a String, long, double or boolean in Java?

A switch on String is allowed since Java 7 and uses equals semantics. Classic constant switches on long, float, double and boolean are not allowed in standard Java, including Java 25. Primitive type patterns in switch (JEP 507) are only a preview feature in Java 25 and require --enable-preview, so do not rely on them in production.

Why does Java not allow if (number) like C or JavaScript?

Java requires the condition of if, while, for and the ternary operator to be of type boolean. There is no implicit conversion from int, null or empty strings to a boolean. This prevents the classic if (x = 5) bug and makes intent explicit: write if (number != 0).

What is a labeled break in Java and when should I use it?

A label is an identifier followed by a colon placed before a loop (outer:). break outer; exits that specific loop even from inside nested inner loops, and continue outer; moves to its next iteration. Use it for multi-level searches in matrices; otherwise prefer extracting the nested loops into a method that returns.

Is the enhanced for loop slower than the classic for loop?

No. For arrays the compiler generates nearly identical bytecode, and for collections it uses an Iterator, which is the correct and efficient way to traverse a LinkedList or Set. Choose the enhanced for loop for readability whenever you do not need the index.

Q1. Explain fall-through in a switch statement. How do you avoid it?

In a classic switch with colon labels, after a matching case the execution continues into the following cases until a break is reached. It is avoided by writing break at the end of every case or, in Java 14 and later, by using arrow labels (case 1 -> ...), which execute exactly one branch and never fall through.

Q2. What is yield in Java and when is it required?

yield is a contextual keyword introduced with switch expressions in Java 14. It returns a value from a block-bodied case in a switch expression (case 2 -> { ...; yield 10; }), or from colon-label cases inside a switch expression. It is not used in switch statements and is not a reserved word, so a variable can still be named yield.

Q3. What does it mean that a switch expression must be exhaustive?

Every possible value of the selector must be matched by some case. For int, char or String selectors this requires a default. For an enum or a sealed type, covering all constants or permitted subtypes is sufficient, and the compiler reports an error if one is missing — which is why switch expressions over enums are safer than if-else ladders.

Q4. What is the output of a loop that declares for (int i = 0; i < 5; i++); followed by a block?

The semicolon ends the loop with an empty body, so the loop runs five times doing nothing, and the block runs once afterwards. Note that i is out of scope in the block, so referencing it there is a compile error.

Q5. Difference between while and do-while, with a real use case.

while checks the condition before each iteration and may run zero times; do-while checks after the body and always runs at least once. Menu-driven programs and input validation loops are the classic use cases for do-while because the prompt must be shown at least once.

Q6. How do you break out of two nested loops in Java?

Use a labeled break: place outer: before the outer loop and write break outer; inside the inner loop. Alternatives are a boolean flag checked by both loops, or moving the loops into a method and using return. Java has no goto.

Q7. Why does for (double d = 0; d != 1; d += 0.1) never end?

Because 0.1 cannot be represented exactly in binary floating point, after ten additions d is approximately 0.9999999999999999, then 1.0999999999999999, never exactly 1.0. Use an integer counter or a < comparison.

Q8. Can you modify an ArrayList inside an enhanced for loop?

Not structurally: adding or removing elements throws ConcurrentModificationException on the next iteration because the list's modification count no longer matches the iterator's. Use Iterator.remove(), removeIf, or iterate over a copy. Changing the state of the element objects themselves is fine.

Q9. What is pattern matching for switch and which Java version made it final?

It lets case labels be type patterns (case String s), record patterns (case Point(int x, int y)) and guarded patterns (case Integer i when i > 0), with support for case null. The selector can be any reference type. It became final in Java 21 (JEP 441 and JEP 440).

Q10. Write the logic for a centred star pyramid of height n.

For row i from 1 to n, print n - i spaces followed by 2i - 1 stars, then a newline. In Java 11+: System.out.println(" ".repeat(n - i) + "*".repeat(2 * i - 1));. Interviewers then often ask for the inverted version (loop i from n down to 1) or a diamond (pyramid plus inverted pyramid of height n - 1).

Build a console program that brings together everything in this lecture: a do-while menu loop, a switch expression to map the user's choice to an action, if/else validation, classic and enhanced for loops, a while digit loop, break, continue and a labeled break. The program offers these options:

1. Check whether a number is prime.
2. Print the multiplication table of a number.
3. Reverse a number and report whether it is a palindrome.
4. Print a centred star pyramid of a given height.
5. Convert marks to a grade with a switch expression.
6. Find a value in a 3 × 3 matrix using a labeled break.
7. Exit.

Save the file as NumberToolkit.java, compile with javac NumberToolkit.java, and run with java NumberToolkit (or simply java NumberToolkit.java on Java 11+). The program uses only standard-library classes and runs on Java 21 and Java 25. After it works, extend it yourself: add an option that prints Floyd's triangle, add input validation that rejects negative numbers with continue, and convert the grade logic to use an enum so the switch becomes exhaustive without a default. Those three extensions are typical follow-up questions in a practical interview round.

• Control flow decides which statements run and how many times: conditionals (if/else, ternary), selection (switch) and loops (for, enhanced for, while, do-while).
• Java conditions must be boolean; there is no truthy/falsy conversion, which stops if (x = 5) at compile time. Always use braces and order else-if ladders from the most specific range downward.
• Flatten deep nesting with short-circuit &&/||, guard clauses and extracted methods; use the ternary operator only for simple value selection.
• The classic switch falls through without break, accepts only constants, and throws on a null String selector.
• Switch expressions (final in Java 14) use arrow labels with no fall-through, allow multiple labels per case, must be exhaustive, return a value and use yield inside block branches.
• Pattern matching for switch (final in Java 21) adds type patterns, record patterns, when guards and case null. Primitive type patterns are still preview in Java 25 — do not use them in production.
• Use for for counted loops, enhanced for to visit every element without an index, while for condition-driven loops and do-while when the body must run at least once (menus, validation).
• break exits the innermost loop, continue skips to the next iteration, and labels (break outer;) control nested loops without flags.
• Know the standard loop patterns — accumulate, max-so-far, search with early exit, digit processing, two-pointer reverse, prime check, Fibonacci, pairwise nested loops — and the pattern-printing recipe: outer loop = row, formulas for spaces and symbols in terms of i and n.
• Avoid the classic mistakes: missing break, == on strings, off-by-one, floating-point counters, overflowing counters, stray semicolons after loop headers and modifying a list inside a for-each loop.

Next lecture: Methods, Arrays & Strings