Control Flow

break exits the loop immediately. continue skips the rest of the current iteration and jumps to the next condition check. A label like outer: lets break/continue target an outer loop instead of the innermost one.

A common pattern is reading until a stop signal: while ((line = reader.readLine()) != null) { ... }. The loop keeps going until the read returns a special value (a sentinel, like null or -1) that means there is no more data.

Use break/continue when the loop's work belongs in the current method and you just need to stop or skip. Prefer extracting the loop into its own method and using return when the loops are deeply nested or the logic is complex, because return exits everything cleanly and reads better.

Make the class implement Iterable<T> and provide an iterator() method that returns an Iterator<T> with working hasNext() and next() methods. Then it can be used directly in for-each.

Avoid for-each when you need the index, want to go in reverse or skip elements, must remove items, or must walk two collections together. Use a classic indexed for loop, an explicit Iterator, or removeIf instead.

A counter declared in the for header only exists inside the loop. Common bugs are using < vs <= wrongly (off-by-one), modifying the counter inside the body, and changing the collection size while looping by index.

A guard clause checks an invalid or special case early and returns immediately, so the main logic stays unindented. Prefer it over deep nesting because it keeps code flat and easier to read.

A pattern switch must handle every possible value (be exhaustive). If you switch over a sealed type, the compiler knows all its allowed subtypes, so once you cover each one you don't need a default — and if someone adds a new subtype later, the switch stops compiling until you handle it.

Replace each if (x instanceof T t) branch with a case T t -> label in a switch over x. Use guards (when) for the extra conditions, keep the most specific cases first, add case null if null is possible, and make it exhaustive with a default or full subtype coverage.

A catch block is a compile error if its exception type can never be thrown by the try body. For checked exceptions, you can't catch a type the try can't throw; but you can always catch RuntimeException, Error, or Exception, because those can occur anywhere.

Java evaluates the while condition before each iteration as a boolean expression. The condition can have side effects (like assignment) and uses short-circuit && / || so later parts may not run. Choose while when iteration count is unknown and for when it is known.

The compiler turns a switch into one of two jump instructions: tableswitch (a dense jump table) or lookupswitch (a sorted list of key/offset pairs). All cases share one scope, so a variable declared in one case is visible (but maybe uninitialized) in the others.

The compiler only flags code it can prove unreachable using fixed rules — it doesn't run your program. So code that's effectively dead because of runtime values (like 'if (x > 0) return;' followed by code when x is always positive) is not rejected; only structurally-impossible code is.

A traditional switch throws NullPointerException if the selector is null. Classic arrow switch expressions over enums/strings do the same unless you guard for null first. Adopting them widely improves safety but needs a recent Java version.