ਉਹ ਕ੍ਰਮ ਤੈਅ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ statements ਚੱਲਦੇ ਹਨ। Java conditionals (, ), loops (, , ), ਅਤੇ branching statements (, , ) ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ — ਸਾਥ ਹੀ 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 ਵਿੱਚ ਚਲਦਾ ਰਹਿੰਦਾ ਹੈ), ਜੋ ਇੱਕ ਮਸ਼ਹੂਰ ਬਗ ਸਰੋਤ ਹੈ।
// 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 nested loops ਨੂੰ ਇਕ ਵਾਰ ਵਿੱਚ ਛੱਡ ਸਕਦੇ ਹਨ।
Control flow ਕਿਸੇ ਵੀ ਪ੍ਰੋਗ੍ਰਾਮ ਵਿੱਚ ਤਰਕ ਅਤੇ ਫੈਸਲੇ ਪ੍ਰਗਟ ਕਰਨ ਦਾ ਬੁਨਿਆਦੀ ਢੰਗ ਹੈ — ਹਰੇਕ ਗੈਰ-ਮਾਮੂਲੀ ਵਿਧੀ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।
ਲੀਲਾਵਾਂ ਅਤੇ ਉਹਨਾਂ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਹੈ: switch fall-through gotcha (ਅਤੇ ਜ਼ਿਆਦਾ ਸੁਰੱਖਿਅਤ ਆਧੁਨਿਕ switch expression), while ਅਤੇ do-while ਵਿੱਚ ਅੰਤਰ (ਘੱਟੋ-ਘੱਟ ਇੱਕ ਵਾਰ ਚਲੋ), ਸਾਫ਼ collection iteration ਲਈ for-each, ਅਤੇ branching statements (nested loops ਲਈ ਲੇਬਲ ਕੀਤੇ breaks ਸਮੇਤ)।
ਇਹਨਾਂ ਵਿੱਚ ਮਾਹਰ ਹੋਣਾ — ਅਤੇ ਆਧੁਨਿਕ, ਘੱਟ ਗਲਤੀ-ਪ੍ਰਵੱਖਣ ਵਾਲੀਆਂ ਫਾਰਮਾਂ (switch expressions, for-each) ਨੂੰ ਤਰਜੀਹ ਦੇਣਾ — ਸਹੀ, ਪੜ੍ਹਣਯੋਗ Java logic ਲਿਖਣ ਅਤੇ ਆਮ control-flow bugs ਤੋਂ ਬਚਣ ਲਈ ਬੁਨਿਆਦੀ ਹੈ।