વિધાનો કે જે ક્રમમાં કાર્યान્વિત થાય તે તે નક્કી કરે છે. 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 કોઈપણ પ્રોગ્રામમાં તર્ક અને નિર્ણયો વ્યક્ત કરવાની મૂળભૂત પદ્ધતિ છે — દરેક બિન-તુચ્છ પદ્ધતિ તેનો ઉપયોગ કરે છે.
સંરચનાઓ અને તેમની ઘોષણાઓ સમજવી આવશ્યક છે: switch fall-through gotcha (અને સુરક્ષિત આધુનિક switch expression), while અને do-while (ઓછામાં ઓછા વખત ચલાવો) માટેનો તફાવત, for-each સ્વચ્છ સંગ્રહ પુનરાવર્તન માટે, અને શાખા વિધાનો (નેસ્ટેડ લૂપ્સ માટે લેબલ કરેલ breaks સહિત).
વધુ તર્ફ આધુનિક, ભૂલ-પ્રવણ સ્વરૂપો (switch expressions, for-each) પર પુષ્ટि કરવી — સાચા, વાંચવાયોગ્ય Java તર્ક લખવા અને સામાન્ય control-flow bugs ને અટકાવવા માટે મૂળભૂત છે.