Precisely where does control transfer for break and continue in for, while, and do-while loops, including the for loop's update expression?

## Why the exact transfer point matters `break` and `continue` are *jump statements* — they move execution somewhere other than the next line. To reason about loops correctly you need to know **exactly** where each lands, because the difference between loop types causes real bugs. ## break — same everywhere In every loop type (`for`, `while`, `do-while`), `break` transfers control to the **first statement after the loop body**. The loop condition is **not** re-evaluated, and the for loop's update expression does **not** run. The loop is simply done. ## continue — depends on the loop type `continue` ends the *current iteration* but the landing spot differs: ### for loop The canonical for loop has four parts: `for (init; condition; update) body`. On `continue`, control goes to the **update** expression, runs it, then evaluates **condition** to decide on another iteration. ```java for (int i = 0; i < 5; i++) { // update i++ runs on continue if (i == 2) continue; // -> runs i++, then tests i < 5 System.out.println(i); // 0,1,3,4 } ``` Because the update runs, the counter always advances — no infinite loop. ### while loop `while (condition) body`. On `continue`, control goes **straight to condition**. There is no separate update slot. ```java int i = 0; while (i < 5) { i++; // must advance BEFORE continue can skip it if (i == 3) continue; // -> jumps to (i < 5) System.out.println(i); } ``` If the increment were placed *after* the `continue`, it would be skipped on that iteration, risking an infinite loop. This is the most common while-loop bug. ### do-while loop `do body while (condition);`. The body always runs at least once. On `continue`, control goes to the **condition at the bottom**, which then decides whether to run the body again. ```java int i = 0; do { i++; if (i == 3) continue; // -> jumps to while (i < 5) System.out.println(i); } while (i < 5); ``` ### enhanced for (for-each) `for (T item : collection)`. There is no visible counter; `continue` simply advances to the next element, and `break` leaves the loop. No infinite-loop risk because the iterator advances each pass automatically. ## Mental model Think of `continue` as "go to the *next condition check*, doing whatever the loop normally does between iterations." For a for loop, that between-iteration work is the update expression; for while/do-while there is none, so it goes straight to the condition. ## Summary - break → after the loop, no condition re-check, no for-update. Same in all loop types. - continue → for: run update, then test condition; while/do-while: go straight to condition. - Place the counter increment *before* a continue in a while loop, or use a for loop, to avoid infinite loops.