उस क्रम को निर्धारित करता है जिसमें कथन निष्पादित होते हैं। Java सशर्त (, ), लूप (, , ), और शाखा कथन (, , ) प्रदान करता है — साथ ही switch expressions जैसे आधुनिक सुधार।
ifswitchforwhiledo-whilebreakcontinuereturnif (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";
switch (day) {
case 1: name = "Mon"; break; // ⚠️ break needed — else it FALLS THROUGH
case 2: name = "Tue"; break;
default: name = "Unknown";
}
क्लासिक switch को प्रत्येक case के बाद break की आवश्यकता होती है — इसे भूल जाने से fall-through होता है (निष्पादन अगले case में जारी रहता है), जो एक बदनाम bug स्रोत है।
// 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";
};
आधुनिक switch expression fall-through को समाप्त करता है, एक मान लौटा सकता है, और अधिक स्वच्छ है — नए कोड में पसंदीदा।
// 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);
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 एक लूप से बाहर निकलता है, continue अगली पुनरावृत्ति तक छोड़ता है, return विधि से बाहर निकलता है, और लेबल किए गए breaks नेस्टेड लूप से एक साथ बाहर निकल सकते हैं।
Control flow किसी भी प्रोग्राम में तर्क और निर्णय व्यक्त करने की मूल प्रक्रिया है — हर गैर-तुच्छ विधि इसका उपयोग करती है।
निर्माणों और उनके nuances को समझना आवश्यक है: switch fall-through gotcha (और सुरक्षित आधुनिक switch expression), while और do-while के बीच अंतर (कम से कम एक बार चलाएं), संग्रह पुनरावृत्ति के लिए for-each, और शाखा कथन (नेस्टेड लूप के लिए लेबल किए गए breaks सहित)।
इन्हें महारत हासिल करना — और आधुनिक, कम त्रुटि-प्रवण रूपों (switch expressions, for-each) को प्राथमिकता देना — सही, पठनीय Java तर्क लिखने और सामान्य control-flow bugs से बचने के लिए मौलिक है।