Vilka kontrollflödeskonstruktioner erbjuder Java?

Question

Accepted Answer

**Kontrollflöde** avgör i vilken ordning satser exekveras. Java erbjuder villkor (`if`, `switch`), loopar (`for`, `while`, `do-while`) och branchingsatser (`break`, `continue`, `return`) — plus moderna förbättringar som switch-uttryck. ## Villkor ```java if (score >= 90) { grade = "A"; } else if (score >= 80) { grade = "B"; } else { grade = "F"; } // ternary — concise if/else for a value String status = (age >= 18) ? "adult" : "minor"; ``` ## Traditionell switch ```java switch (day) { case 1: name = "Mon"; break; // ⚠️ break needed — else it FALLS THROUGH case 2: name = "Tue"; break; default: name = "Unknown"; } ``` Den klassiska `switch` kräver `break` efter varje case — att glömma det orsakar **fall-through** (exekvering fortsätter in i nästa case), en känd felkälla. ## Modernt switch-uttryck (Java 14+) — säkrare ```java // arrow syntax: no fall-through, returns a value, more concise String name = switch (day) { case 1 -> "Mon"; case 2 -> "Tue"; case 6, 7 -> "Weekend"; // multiple labels default -> "Unknown"; }; ``` Det moderna switch-uttrycket eliminerar fall-through, kan returnera ett värde och är renare — föredrat i ny kod. ## Loopar ```java // for — known iteration count for (int i = 0; i < 10; i++) { ... } // enhanced for-each — iterate a collection/array for (String item : items) { ... } // while — condition checked BEFORE each iteration while (condition) { ... } // do-while — body runs at least ONCE (condition checked after) do { ... } while (condition); ``` ## Branchingsatser ```java for (int i = 0; i < 10; i++) { if (i == 5) break; // exit the loop entirely if (i % 2 == 0) continue; // skip to the next iteration } return result; // exit the method // labeled break — exit nested loops outer: for (...) { for (...) { if (found) break outer; // breaks BOTH loops } } ``` `break` avslutar en loop, `continue` hoppar till nästa iteration, `return` avslutar metoden, och märkta break kan avsluta kapslade loopar på en gång. ## Varför det spelar roll Kontrollflöde är den grundläggande mekanismen för att uttrycka logik och beslut i alla program — varje icke-trivial metod använder det. Att förstå konstruktionerna och deras nyanser är väsentligt: **switch fall-through gotcha** (och det säkrare moderna switch-uttrycket), skillnaden mellan `while` och `do-while` (kör minst en gång), `for-each` för ren iterering av samlingar, och branchingsatser (inklusive märkta breaks för kapslade loopar). Att behärska dessa — och föredra de moderna, mindre felbenägna formerna (switch-uttryck, for-each) — är grundläggande för att skriva korrekt, läsbar Java-logik och undvika vanliga kontrollflödesfel.