Control Flow

It is a shorter loop for going through every element of an array or collection without a counter. You write 'for (Type item : collection)' and 'item' takes each value in turn.

A for loop has three parts in parentheses, separated by semicolons: initialization, condition, and update. Init runs once first; then each pass checks the condition, runs the body, then runs the update.

An if statement runs a block of code only when its condition is true. An optional else block runs when the condition is false. The condition must be a boolean.

An else-if chain tests conditions in order from top to bottom. The first condition that is true runs its block, and the rest are skipped. An optional final else catches everything else.

A switch expression produces a value you can assign to a variable. The arrow form 'case X -> result;' runs only the matching branch with no fall-through, so you don't need break statements.

A type pattern in a switch case checks whether the value is of a given type and, if so, binds it to a new variable in one step. This lets a switch branch on the runtime type of an object, not just on constants like ints, enums, or strings.

switch picks a branch by comparing one value against case labels. It jumps to the matching case and keeps running downward into later cases until it hits a break (or the end). default runs when nothing matches.

Unreachable code is a statement that can never possibly run, such as a line written right after a return. Java treats this as a compile error, so the program will not build until you remove or fix it.

A loop runs forever when its condition never becomes false. To make it terminate, the body must change something that the condition checks (like incrementing a counter) so the condition eventually turns false, or use break.

A while loop checks the condition before running its body, so it may run zero times. A do-while loop runs the body once first, then checks the condition, so it always runs at least once.

Changing the collection's size during a for-each usually throws a ConcurrentModificationException. To remove items safely, use an explicit Iterator and call its remove(), or use collection.removeIf(...).

Use 'yield' to return a value from a switch branch that is a block ({ ... }) and needs more than one statement. Single-expression arrow branches don't need it; they return their value directly.

A guarded pattern adds a boolean condition to a case using when, e.g. case Integer i when i > 0. The case matches only if the value fits the pattern AND the condition is true. If the guard is false, the switch keeps trying later cases.

Fall-through means after a case runs, execution keeps going into the next case unless you write break. It is deliberate when several labels share one body, but a forgotten break is a common bug. Always add break, or stack empty labels on purpose.

A switch expression must cover every possible input value. You either add a 'default' branch or list all values (e.g. every enum constant). If you don't, it won't compile.

Use a for loop when you know the number of repetitions or are counting over a range, because it keeps the counter setup, test, and update together. Use while when you just loop until some condition changes.

You put a name (a label) followed by a colon before a loop, like outer:. Then break outer; exits that labeled loop completely, and continue outer; jumps to the next iteration of that labeled loop. This lets you control an outer loop from inside an inner one.

break sends control to right after the loop in all loop types. continue goes to the loop's condition check, but in a for loop it runs the update part (like i++) first. So a for loop's update always runs on continue; a while/do-while jumps straight to the condition.

An unlabeled break or continue only affects the innermost loop that directly contains it. The outer loop keeps running. So a break inside an inner loop just ends that inner loop, not both.

For an array the compiler turns it into an index-based loop using array.length. For a collection it calls iterator() and uses hasNext()/next(). The source code looks the same, but the generated code differs.

You can list several expressions in the init or update clause separated by commas, like for (int i = 0, j = 10; i < j; i++, j--). The comma lets one loop track two counters at once.

for(;;) is an infinite loop: with all three clauses empty, there is no condition so it never stops on its own. You leave it with break, return, or by throwing an exception.

When an else could attach to more than one nested if, Java's rule is that else binds to the nearest unmatched if above it. Use braces to force the binding you actually want.

&& and || stop evaluating as soon as the result is known: && stops at the first false, || stops at the first true. This lets you safely guard later checks, like checking for null before using a value.

A switch statement does an action and returns nothing; a switch expression computes and returns a value. Use the expression to assign or return a result; use the statement for pure side effects.

By default a switch throws NullPointerException if the value is null. To handle null safely you add case null, which runs only when the value is null. You can also write case null, default to send null to the default branch.

You can switch on int and the smaller whole-number types byte, short, char (and their wrapper classes), on enum constants, and on String. You cannot switch on long, float, double, boolean, or arbitrary objects.

With 'while (true)' and no break, the loop never ends, so any statement written after it can never run. The compiler treats that following code as unreachable and reports a compile error.

The body of 'while (false)' can never run, so Java flags it as unreachable code — a compile error. Java deliberately exempts 'if (false)' from this rule so it can be used to switch code on and off, like a conditional-compilation flag.