Java do-while ලූප් පැහැදිලි කිරීම: ව්‍යවස්ථාව, while ලූප් සමඟ වෙනස්කම්, උදාහරණ සහ සාමාන්‍ය වැරදි

1. හැඳින්වීම

“What’s the difference between a do-while statement and while or for?” යන්න ජාවා ඉගෙන ගන්නා බොහෝ ආරම්භකයන් මුහුණ දෙන පළමු ප්‍රශ්න වලින් එකකි. do-while ලූප් එක පශ්චාත්-පරීක්ෂණ ලූප් එකක් වන අතර කේත කොටස අවම වශයෙන් එක් වරක් ක්‍රියාත්මක වන බව සහතික කරයි. පරිශීලක ආදානය තහවුරු කිරීම හෝ කිසිවක් අවම වශයෙන් එක් වරක් පෙන්වීම වැනි සැබෑ-ලෝක අවස්ථා වලට එය විශේෂයෙන් ප්‍රයෝජනවත් වේ.

මෙම පරිච්ඡේදයේ, ඔබ ඉගෙන ගන්නා දේ පැහැදිලි කර do-while ලූප් එකේ සමස්ත සංකල්පය අවබෝධ කර ගැනීමට උදව් කරමු. පසුගිය කොටස් වලින් ව්‍යවස්ථාව, while සමඟ ඇති වෙනස්කම්, නියැදි කේත, පොදු වැරදි සහ අඩවි ප්‍රශ්න (FAQs) ආදිය ආවරණය කරයි. අවසානයේ, ඔබට එය ස්වභාවිකව සහ විශ්වාසයෙන් භාවිතා කළ හැකි වනු ඇත.

ඉලක්ක ප්‍රේක්ෂකයෝ

• ජාවා ආරම්භකයන් සිට තම මූලික දැනුම ශක්තිමත් කිරීමට කැමති අය දක්වා
• ඕනෑම කෙනෙකුට while සහ do-while අතර වෙනස්කම් සහ සුදුසු භාවිතා අවස්ථා උදාහරණ සමඟ අවබෝධ කර ගැනීමට
• අසීමිත ලූප් හෝ අර්ධවිරම (semicolon) අතුරුදන් වීම වැනි සාමාන්‍ය ආරම්භක වැරදි වලින් වැළැක්වීමට කැමති පාඨකයන්

ඔබ ඉගෙන ගන්නා දේ

• do-while ලූප් එකේ මූලික ව්‍යවස්ථාව සහ හැසිරීම (පශ්චාත්-පරීක්ෂණ / අවම වශයෙන් එක් වරක් ක්‍රියාත්මක වේ)
• while සහ do-while අතර පැහැදිලි වෙනස්කම්, සහ නිවැරදි එක තෝරා ගැනීමේ ක්‍රමය
• ආරම්භක‑හිතකාමී නියැදි කේත සහ ප්‍රතිඵලය කියවීමේ ක්‍රමය
• break සහ continue භාවිතා කරන විට සැලකිලිමත් විය යුතු වැදගත් කරුණු
• සාමාන්‍ය දෝෂ සහ වැරදි (අර්ධවිරම අතුරුදන් වීම, නියමිත තත්ත්ව සැලසුම නිසා අසීමිත ලූප් වැනි)

ඊළඟ කොටස් වල, අපි ව්‍යවස්ථාවෙන් ආරම්භ කර, පියවරෙන් පියවර සසඳුම්, උදාහරණ, සහ අවවාදයන් හරහා ඔබේ අවබෝධය තදබල කර ගැනීමට යමු.

2. ජාවා do-while ප්‍රකාශය කුමක්ද? (මූලික ව්‍යවස්ථාව)

ජාවා for සහ while වැනි බොහෝ ලූප් ව්‍යුහයන් ලබා දේ, නමුත් do-while ලූප් එකට විශේෂ ලක්ෂණයක් ඇත. එය කේත කොටස පළමුව ක්‍රියාත්මක කර, පසුදා තත්ත්වය පරීක්ෂා කරයි, එබැවින් එය පශ්චාත්-පරීක්ෂණ ලූප් ලෙස හැඳින්වේ.

අන්‍ය ලූප් වල තත්ත්වය ක්‍රියාත්මක කිරීමට පෙර පරීක්ෂා කරයි, එමනිසා කේතය කිසිවක් ක්‍රියා නොකළ හැකිය. එයට විරුද්ධව, do-while ලූප් එක සෑම විටම අවම වශයෙන් එක් වරක් ක්‍රියා කරයි, එය විශේෂ අවස්ථා සඳහා සුදුසු වේ.

මූලික ව්‍යවස්ථාව

do {
    // Code to execute
} while (condition);

එක් වැදගත් විස්තරයක් නම්, ඔබ while (condition) පසු අර්ධවිරම (;) එකක් ඇතුළත් කළ යුතුය. එය අමතක කළහොත් සංකලනයේ දෝෂයක් සිදුවේ.

ක්‍රියාත්මක වීමේ ප්‍රවාහය

1. do { ... } තුළ කේතය ක්‍රියාත්මක කරන්න
2. while (condition); තත්ත්වය පරීක්ෂා කරන්න
3. තත්ත්වය true නම්, ලූප් එක නැවත කරන්න
4. තත්ත්වය false නම්, ලූප් එකෙන් පිටවන්න

සාරාංශයෙන්, ක්‍රමය මෙසේය: ක්‍රියාත්මක කිරීම → පරීක්ෂා කිරීම → නැවත කිරීම.

සරල උදාහරණ

int count = 1;

do {
    System.out.println("Loop count: " + count);
    count++;
} while (count <= 3);

ප්‍රතිඵල

Loop count: 1
Loop count: 2
Loop count: 3

තත්ත්වය ක්‍රියාත්මක කිරීමෙන් පසු පරීක්ෂා කරන නමුත්, පණිවුඩය සෑම විටම අවම වශයෙන් එක් වරක් මුද්‍රණය වේ.

3. while සහ do-while අතර පැහැදිලි වෙනස්කම්

ජාවා තුළ, සාමාන්‍යතම ලූප් ප්‍රකාශන while සහ do-while වේ. ඒවා සමාන පෙනුමක් ඇති නමුත්, තත්ත්වය කවදා පරීක්ෂා කරයි යන වැදගත් වෙනස්කමක් ඇත. මෙම වෙනස්කම අවබෝධ කර ගැනීම නිවැරදි ලූප් එක තෝරා ගැනීමට ඉතා පහසු කරයි.

while ප්‍රකාශයේ ක්‍රියාත්මක කිරීමේ අනුක්‍රමය

while (condition) {
    // Code to execute
}

• 1. තත්ත්වය පළමුව පරීක්ෂා කරයි
• 2. තත්ත්වය true නම් පමණක් කේතය ක්‍රියාත්මක වේ
• 3. තත්ත්වය false නම්, කේතය කිසිවිටෙකත් ක්‍රියා නොකරයි

do-while ප්‍රකාශයේ ක්‍රියාත්මක කිරීමේ අනුක්‍රමය

do {
    // Code to execute
} while (condition);

• 1. කේතය පළමුව ක්‍රියාත්මක වේ
• 2. තත්ත්වය පසුදා පරීක්ෂා කරයි
• 3. තත්ත්වය true නම්, ලූප් එක නැවත ක්‍රියා කරයි
• 4. තත්ත්වය false නම්, ලූප් එක අවසන් වේ

සසඳුම් වගුව

සහජ්ඣාතමක විස්තරය

• while loop : “ස්ථානයකට පිවිසීමට පෙර ටිකට් පරීක්ෂා කිරීම.” ඔබට ටිකට් නැත්නම්, ඔබ කිසිදා පිවිසෙන්නේ නැත.
• do-while loop : “පළමුව ස්ථානයට පිවිසීම, පසුතැවෙන විට ටිකට් පරීක්ෂා කිරීම.” ඔබට අවම වශයෙන් එක් වරක්වත් පිවිසෙන්න පුළුවන්.

Simple Comparison Code

int x = 5;

// while loop
while (x < 5) {
    System.out.println("while: executed");
}

// do-while loop
do {
    System.out.println("do-while: executed");
} while (x < 5);

ප්‍රතිඵලය

do-while: executed

ආරම්භයෙන්ම කොන්දේසිය false වුවත්, do-while ලූපය තවමත් එක් වරක් ක්‍රියා කරයි.

4. Java do-while Loop Examples (Beginner‑Friendly)

දැන් අපි do-while ලූපය භාවිතා කරන ප්‍රායෝගික උදාහරණ බලමු, එය කෙසේ ක්‍රියා කරන්නේද යන්න හොඳින් තේරුම් ගැනීමට. මතක තබා ගත යුතු ප්‍රධාන කරුණ වන්නේ ලූපය අවම වශයෙන් එක් වරක්වත් ක්‍රියා කරයි.

Basic Example: Repeating a Counter

int count = 1;

do {
    System.out.println("Hello! Count: " + count);
    count++;
} while (count <= 3);

ප්‍රතිඵලය

Hello! Count: 1
Hello! Count: 2
Hello! Count: 3

මෙම උදාහරණයේ, count 3 ට සමාන හෝ අඩු වන තෙක් පණිවුඩය පෙන්වයි. කොන්දේසිය ක්‍රියාත්මක කිරීමෙන් පසු ඇගයෙන්නේ බැවින්, පණිවුඩය අවම වශයෙන් එක් වරක්වත් මුද්‍රණය වේ.

When the Condition Is False from the Start

int num = 10;

do {
    System.out.println("This code runs!");
} while (num < 5);

ප්‍රතිඵලය

This code runs!

කොන්දේසිය num < 5 ආරම්භයේ වැරදි (false) වුවත්, ලූපය තවමත් එක් වරක් ක්‍රියා කරයි. මෙම හැසිරීම do-while ලූපයට විශේෂයි.

Using Random Numbers: Roll a Die Until You Get 6

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        Random rand = new Random();
        int dice;

        do {
            dice = rand.nextInt(6) + 1; // Random number from 1 to 6
            System.out.println("Dice roll: " + dice);
        } while (dice != 6);

        System.out.println("You rolled a 6. The loop ends!");
    }
}

උදාහරණ ප්‍රතිඵලය

Dice roll: 2
Dice roll: 5
Dice roll: 6
You rolled a 6. The loop ends!

මෙම වැඩසටහන 6 එකක් පෙනෙන තුරු පට්ටිය ගලවයි. while ලූපයක් භාවිතා කරන විට, කොන්දේසිය ආරම්භයේ වැරදි නම් කේතය කිසිදා ක්‍රියා නොකරනු ඇත, නමුත් do-while ලූපය අවම වශයෙන් එක් ගැලවීමක් වගකීම් කරයි.

Key Takeaways

• කේතය අවම වශයෙන් එක් වරක් ක්‍රියාත්මක කිරීම අවශ්‍ය වන විට (උදා: පරිශීලක ඇතුළත් කිරීම, මුල් උත්සාහ) සුදුසුය.
• කේත උදාහරණ භාවිතා කර do-while සහ while අතර සංසන්දනය කිරීමෙන් වෙනස තේරුම් ගැනීම පහසු වේ.

5. When to Use do-while: Pros and Cons

මෙතෙක් අපි ව්‍යුහය සහ උදාහරණ ආවරණය කර ඇත. දැන් කවදා do-while ලූපයක් භාවිතා කළ යුතුද යන්න සාකච්ඡා කර, එහි වාසි සහ අවාසි පරීක්ෂා කරමු.

Recommended Use Cases

1. When the code must run at least once wp:list /wp:list

   • පරිශීලක ඇතුළත් කිරීම (උදා: තහවුරු කිරීමේ සංවාද) සඳහා ප්‍රශ්න කිරීම.
   • කොන්දේසිය පරීක්ෂා කිරීමට පෙර පට්ටියක් අවම වශයෙන් එක් වරක් ගලවීම.
   • ගොනු ප්‍රවේශය හෝ සම්බන්ධතා පරීක්ෂා කිරීම අවම වශයෙන් එක් වරක් උත්සාහ කිරීම.

2. When post‑condition logic feels more natural wp:list /wp:list

   • “පළමුව උත්සාහ කර, පසුතැවෙන විට දිගටම කරගෙන යාම තීරණය කිරීම” වැඩපිළිවෙළ.

Advantages

• අවම වශයෙන් එක් ක්‍රියාත්මක කිරීමේ සහතිකය ඔබට සැමවිටම පණිවුඩයක් පෙන්වීමට හෝ මුල් ක්‍රියාවක් කිරීමට අවශ්‍ය වන විට ප්‍රයෝජනවත්.
• ඇතුළත් කිරීමේ වලංගුකරණය සහ පරීක්ෂණ‑අධාරිත තර්ක සඳහා සුදුසු කොන්දේසිය පරීක්ෂා කිරීමට පෙර එක් වරක් ක්‍රියාත්මක කිරීමට අවශ්‍ය අවස්ථා සඳහා ලූප ව්‍යුහය ස්වභාවිකව ගැලපේ.

Disadvantages

• කොන්දේසිය සමහර අවස්ථාවල කියවීමට අඩු වීම do-while ගැන නොදන්නා සංවර්ධකයන්ට තර්කය අඩු තේරුම්ගත හැක.
• භාවිතය අඩු වීම වාස්තු විද්‍යාත්මක ව්‍යාපෘතිවල for සහ while ලූපයන් වැඩි වශයෙන් භාවිතා වේ. do-while අධික ලෙස භාවිතා කිරීම සමඟ කණ්ඩායම් සාමාජිකයන්ට ගැටළුවක් ඇති විය හැක.

Summary

• do-while ලූපය භාවිතා කිරීම අවම වශයෙන් එක් වරක් ක්‍රියාත්මක කිරීම සඳහා පැහැදිලි හේතුවක් තිබේ නම් පමණක් කරන්න.
• බොහෝ අනෙකුත් අවස්ථාවල, while හෝ for ලූපයන් වඩා ආරක්ෂිත සහ පැහැදිලි තේරීම් වේ.

6. Combining do-while with break and continue

do-while ලූපය break සහ continue යන දෙක සමග ඒකාබද්ධ කළ විට තවත් නම්‍යශීලී වේ. පොදු භාවිතා රටා බලමු.

break: ලූපයෙන් කලින් නික්මීම

break ප්‍රකාශනය ලූපය වහාම අවසන් කරයි. එය do-while ලූපය තුළද එලෙසම ක්‍රියා කරයි.

int count = 1;

do {
    if (count > 5) {
        break;  // Exit the loop when count exceeds 5
    }
    System.out.println("Count: " + count);
    count++;
} while (true);

System.out.println("Loop has ended");

Output

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5
Loop has ended

මෙය while (true) නිසා අනන්ත ලූපයක් මෙන් පෙනුනත්, break ප්‍රකාශනය නිසිගතිකරණයක් සහතික කරයි.

continue: මීළඟ පුනරාවර්තනයට මගහැරීම

continue ප්‍රකාශනය වර්තමාන පුනරාවර්තනයේ ඉතිරි කේතය මගහැරෙන අතර මීළඟ තත්ත්ව පරීක්ෂාවට යයි.

int num = 0;

do {
    num++;
    if (num % 2 == 0) {
        continue;  // Skip even numbers
    }
    System.out.println("Odd number: " + num);
} while (num < 5);

Output

Odd number: 1
Odd number: 3
Odd number: 5

මෙම උදාහරණයේ, සම අංක මගහැරෙන අතර විස්ථ අංක පමණක් මුද්‍රණය වේ.

ප්‍රායෝගික උදාහරණය: පරිශීලක ආදාන ලූපය

පොදු රටාවක් වන්නේ අවම වශයෙන් එක් පරිශීලක ආදානයක් බල කිරීම, ඉන්පසු තත්ත්වයක් පූර්ණ වූ විට නික්මීම.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input;

        do {
            System.out.print("Type 'exit' to quit: ");
            input = scanner.nextLine();

            if (input.equals("exit")) {
                break;
            }
            System.out.println("You entered: " + input);

        } while (true);

        System.out.println("Program terminated");
    }
}

ප්‍රධාන කරුණු

• break → ලූපය සම්පූර්ණයෙන් නික්මීම
• continue → වර්තමාන පුනරාවර්තනය පමණක් මගහැරීම
• මේවා do-while සමග ඒකාබද්ධ කිරීමෙන් නම්‍යශීලී පාලනයක් ලැබෙන අතර අවම වශයෙන් එක් ක්‍රියාත්මක වීම සහතික වේ

7. සුලබ දෝෂ සහ වැදගත් සටහන්

do-while ලූපයේ සරල ව්‍යුහයක් තිබුනත්, ආරම්භකයින්ට සුලබව සිදුවන සමහර සුලබ දෝෂ ඇත. පහත දැක්වෙන්නේ වඩාත් සුලබ දෝෂ සහ ඔබ සැලකිලිමත්ව ගෙනහැර දැකිය යුතු කරුණු.

1. සෙමිකොලන් අමතක කිරීම

do-while ලූපයක, while (condition) පසුව සෙමිකොලන් අනිවාර්යයි. එය අමතක කළහොත් සංකලන දෝෂයක් ඇති වේ.

// ❌ Incorrect: causes a compilation error
do {
    System.out.println("Processing");
} while (x < 5)   // Missing semicolon

// ✅ Correct
do {
    System.out.println("Processing");
} while (x < 5);

2. අනන්ත ලූප

ලූප තත්ත්වය කවදාහරි false නොවුනොත්, ලූපය කවදාවත් නොනවස්. මෙය බොහෝ විට තත්ත්වයේ භාවිතා වන විචල්‍යය යාවත්කාලීන නොවූ විට සිදු වේ.

int x = 1;

do {
    System.out.println("Execution: " + x);
    // x is never updated, so the condition remains true
} while (x > 0);

මෙම කේතය අනන්ත ලූපයක් ඇති කරයි. වැඩිදුරටත් තත්ත්වය අවසානයේ වෙනස් වී ලූපය අවසන් කළ හැකි බව සහතික කරන්න.

3. අනිවාර්ය නොවන තනි ක්‍රියාත්මක වීම

do-while ලූපය සැමවිටත් අවම වශයෙන් එක් වරක් ක්‍රියාත්මක වන නිසා, ඔබ ලූප කිරීමට අදහස් නොකළත් කේතය තනි වරක් ක්‍රියාත්මක විය හැක.

int num = 10;

do {
    System.out.println("Executed");
} while (num < 5);

Output

Executed

ඔබේ අදහස සම්පූර්ණයෙන් ක්‍රියාත්මක වීම මගහැරීම නම්, මෙම හැසිරීම දෝෂ ඇති කළ හැක. සැලකිලිමත් තත්ත්ව සැලසුම්කරණය අත්‍යවශ්‍යයි.

4. do-while සහ while මිශ්‍ර කිරීම

ආරම්භකයින් බොහෝ විට do-while while මෙන්ම හැසිරෙන බව සිතති. do-while සැමවිටත් එක් වරක් ක්‍රියාත්මක වේ යන දේ අමතක කිරීම සුලුවෙන් අනපේක්ෂිත ප්‍රතිඵලවලට ලේදු කළ හැක.

සාරාංශය

• සෙමිකොලන් අමතක කිරීම වඩාත් සුලබ දෝෂය
• අනන්ත ලූප වළක්වා ගැනීමට විචල්‍ය යාවත්කාලීන කරන්න
• “අවම වශයෙන් එක් වරක් ක්‍රියාත්මක වේ” නීතිය මතක තබා ගනිමින් තත්ත්ව සැලසුම් කරන්න

8. FAQ (පොදු ප්‍රශ්න)

do-while loop එක ඉගෙන ගන්නා ආරම්භකයින් බොහෝ විට අහන ප්‍රශ්න පහත දැක්වේ, වේගවත් ආධාරක සඳහා Q&A ආකෘතියෙන් ඉදිරිපත් කර ඇත.

Q1. මම do-while loop එක කවදා භාවිතා කළ යුතුද?

A: කේතය අවම වශයෙන් වතාවක් ක්‍රියාත්මක විය යුතු විට එය භාවිතා කරන්න. සාමාන්‍ය උදාහරණවලට පරිශීලක ආදාන ඉල්ලීම් හෝ තීරණ ගැනීමට පෙර සිදු කළ යුතු මුල් පරීක්ෂණ ඇතුළත් වේ.

Q2. while සහ do-while අතරින් මම කෙසේ තෝරා ගත යුතුද?

A:

• while loop → කොන්ඩිෂන් සපුරාලීමේදී පමණක් කේතය ක්‍රියාත්මක කරන්න
• do-while loop → කොන්ඩිෂන් සලකා බැලීමකින් තොරව අවම වශයෙන් වතාවක් කේතය ක්‍රියාත්මක කරන්න

බොහෝ අවස්ථාවලදී, while ප්‍රමාණවත් ය. තනි වරක සහතික කළ ක්‍රියාකාරීත්වයක් අවශ්‍ය වන විට do-while තෝරන්න.

Q3. මගේ loop එක අනන්ත වීමට හේතුව මොකක්ද?

A: loop කොන්ඩිෂන් එක සැමවිටම true ලෙස විග්‍රහ කරන විට මෙය සිදු වේ. සාමාන්‍ය හේතුවලට loop variables යාවත්කාලීන නොකිරීම හෝ නිසි පිටවීමේ කොන්ඩිෂන් එකක් නිර්වචනය නොකිරීම ඇතුළත් වේ.

විසඳුම වන්නේ කොන්ඩිෂන් එක අවසානයේ false විය හැකි බව සහතික කිරීම ය.

Q4. do-while loop එක සැබෑ ව්‍යාපෘතිවලදී සුලභව භාවිතා වේද?

A: ඉතා සුලභව නොවේ. බොහෝ නිෂ්පාදන කේත for හෝ while loops මත රඳා පවතී. නමුත්, do-while පරිශීලක ආදාන කළමනාකරණය හෝ තහවුරුකිරීම් loops වැනි තත්ත්වයන් සඳහා තවමත් ගුණදායක ය.

Q5. මම do-while නොසලකා හැරියත් Java හි ප්‍රොග්‍රෑම් කළ හැකිද?

A: for සහ while භාවිතයෙන් බොහෝ වැඩසටහන් ලියන්න පුළුවන්. නමුත්, loop හැසිරීම වැරදි විග්‍රහයන් වළක්වා ගැනීමට සහ පවතින කේත කියවීමට do-while තේරුම් ගැනීම අත්‍යවශ්‍ය ය.

Q6. while එකෙන් පසුව සෙමිකොලන් අනිවාර්යද?

A: ඔව්. while (condition) එකෙන් පසුව සෙමිකොලන් අවශ්‍ය ය. එය නොලියන්නේ නම් කම්පයිලේෂන් දෝෂයක් ඇති වේ.

9. අවසාන සාරාංශය

ජාවා do-while loop එක මූලික සිට ප්‍රායෝගික භාවිතය දක්වා ආවරණය කළෙමු. වඩාත් වැදගත් කරුණු සමාලෝචනය කරමු.

do-while Loop එකේ ප්‍රධාන ලක්ෂණ

• සැමවිටම අවම වශයෙන් වතාවක් ක්‍රියාත්මක වන loop එකක්
• ක්‍රියාකාරීත්ව ක්‍රමය ක්‍රියාව → කොන්ඩිෂන් පරීක්ෂාව (පසු-පරීක්ෂණ loop එකක්)
• ප්‍රකාශනයේ අවසානයේ සෙමිකොලන් එකක් අවශ්‍ය ය

while Loop එකෙන් වෙනස්කම්

• while → ක්‍රියාකාරීත්වයට පෙර කොන්ඩිෂන් පරීක්ෂා කරයි; කේතය කිසිදාහරි නොධාවනු ඇත
• do-while → අවම වශයෙන් වතාවක් ක්‍රියාකාරීත්වය සහතික කරයි

ප්‍රායෝගික භාවිත අවස්ථා

• පරිශීලක ආදානය අවම වශයෙන් වතාවක් ඉල්ලා සිටිය යුතු විට
• ගැටලුවලට උත්තර සෙවීම් වැනි උත්සාහ-පදනම් පුනරාවර්තනයන් හෝ සම්බන්ධතා පරීක්ෂණ
• break සහ continue සමඟ ඒකාබද්ධ වූ නම්‍යශීලී පාලනය

වැදගත් අනතුරු ඇඟවීම්

• අනුපසථ සෙමිකොලන් හේතුවෙන් ඇති වන කම්පයිලේෂන් දෝෂ
• variables යාවත්කාලීන නොකිරීම හේතුවෙන් ඇති වන අනන්ත loops
• ක්‍රියාකාරීත්වය සැමවිටම වතාවක් සිදු වන බව මතක තබා ගනිමින් කොන්ඩිෂන්ස් සැලසුම් කරන්න

මෙම දැනුම භාවිතා කිරීම

• භාවිත මාර්ගය අඩු වුවද, පවතින කේත කියවීම සහ නඩත්තු කිරීම සඳහා do-while තේරුම් ගැනීම අත්‍යවශ්‍ය ය
• අනුපදාන වශයෙන් for හෝ while භාවිතා කරන්න, සහ තර්කයට ගැලපෙන විට පමණක් do-while භාවිතා කරන්න

සාරාංශයක් ලෙස, සහතික කළ ක්‍රියාකාරීත්වයක් අවශ්‍ය වන විට do-while loop එක බලවත් ව්‍යුහයක් ය. එය තේරුම් ගැනීමෙන් ජාවා loop පාලනය පිළිබඳ ඔබගේ අවබෝධය ගැඹුරු කරන අතර, පැහැදිලි, වඩා විශ්වාසනීය කේත ලිවීමට උපකාරී වේ.