Java Programming Sinhala - Part 04: The Master Guide to Loops, Validation & Debugging Secrets 🔄🐞

හිතන්න ඔයාට ඔයාගේ නම 1000 වතාවක් Print කරන්න ඕනේ කියලා. ඔයා 1000 වතාවක් System.out.println ගහනවද? එහෙම කළොත් පේළි 1000ක් නිකරුණේ නාස්ති වෙනවා. 🤯

Software Engineer කෙනෙක්ගේ ප්‍රධානම ලක්ෂණය තමයි "වැඩේ ලේසි කරගැනීම(කම්මැළිකම)". කම්මැළි හැමෝම Software Engineersලා නෙවෙයි හොඳේ😁😉. අපි කැමති නෑ එකම දේ ආයේ ආයේ ලියන්න. අන්න ඒකට විසඳුම තමයි Loops (පුනරාවර්තන). අද අපි Java වල තියෙන Loops ගැන A-Z වගේම, Software Industry එකේ පාවිච්චි වෙන Input Validation සහ Debugging Secrets (රබර් තාරාවාගේ රහස) ගැනත් ගැඹුරින්ම ඉගෙන ගමු. 🦆

1. ඇයි අපිට Loops ඕන වෙන්නේ? 🔄

සරලවම කිව්වොත්, Loops කියන්නේ යම්කිසි කෝඩ් කොටසක්, අපි දෙන කොන්දේසියක් (Condition) සත්‍ය වන තුරු නැවත නැවත ක්‍රියාත්මක කිරීමයි. මේකෙන් අපේ කාලය සහ කෝඩ් පේළි ගණන ඉතුරු වෙනවා.

Loops වර්ග 2ක් තියෙනවා:

• 1. Finite Loops: දන්නා වාර ගණනක් වැඩ කරන ඒවා. (උදා: 1 සිට 10 ට Print කිරීම).
• 2. Infinite Loops: කවදාවත් නොනවතින ඒවා. (වැරදීමකින් හෝ ඕනෑකමින්ම නවත්වන තුරු දිගටම වැඩ කරයි).

2. While Loop (Entry-Controlled) 🚪

මේක හරියට "ගෙදරට යන්න කලින් දොර අරිනවා" වගේ. Loop එක ඇතුලට යන්න (Run වෙන්න) කලින්ම Condition එක Check කරනවා. Condition එක බොරු (False) නම්, එක පාරක්වත් මේක වැඩ කරන්නේ නෑ.

භාවිතා කරන අවස්ථා:

අපිට Loop එක කී පාරක් වැඩ කරනවද කියලා හරියටම ෂුවර් නැති වෙලාවට මේක පාවිච්චි කරනවා. උදාහරණයක් විදියට "User හරි Password එක ගහනකම් අහන්න" වගේ තැන් වලදී.

// Password Checker Example
String correctPass = "Java123";
String inputPass = "";

// පාස්වර්ඩ් එක වැරදි තාක් කල් (While) මේක අහනවා
while (!inputPass.equals(correctPass)) {
    System.out.print("Enter Password: ");
    inputPass = sc.next();
}
System.out.println("Access Granted! ✅");

3. Do-While Loop (Exit-Controlled) 🛑

මේක ටිකක් විශේෂයි. Condition එක බලන්නේ අන්තිමට. ඒ කියන්නේ Condition එක බොරු වුනත්, අඩුම තරමේ එක පාරක් හරි මේක වැඩ කරනවාමයි.

Pro Tip: මෙනු (Menu) එකක් හදන්න මේක නියමයි. මොකද මුලින්ම මෙනු එක පෙන්නලා ඊට පස්සේ තමයි User ගේ කැමැත්ත අහන්නේ.

int option;
do {
    System.out.println("1. Play Game");
    System.out.println("2. Exit");
    option = sc.nextInt();
} while (option != 2); // 2 ගැහුවොත් නවතින්න

4. For Loop (The Popular One) ⭐

අපිට වාර ගණන හරියටම දන්නවා නම් (උදා: 1 සිට 100 ට), ලේසිම ක්‍රමය මේකයි. එකම පේළියේ ඔක්කොම තියෙනවා.

Syntax: for (initialization; condition; update)

// 0 සිට 10 ට ඉරට්ටේ සංඛ්‍යා (Even Numbers)
for (int i = 0; i <= 10; i = i + 2) {
    System.out.println("Even: " + i);
}

5. Nested Loops (පුඩුවක් ඇතුලේ පුඩුවක්) 🕸️

Loop එකක් ඇතුලේ තව Loop එකක් දාන්න පුළුවන්. මේකට කියන්නේ Nested Loops කියලා. මේවා ගොඩක් වෙලාවට පාවිච්චි වෙන්නේ රටා (Patterns) මවන්න සහ Matrix (Table) එක්ක වැඩ කරන්නයි.

Challenge: Star Pattern එකක් හදමු!

for (int i = 1; i <= 5; i++) { // පේළි ගණන (Rows)
    for (int j = 1; j <= i; j++) { // තරු ගණන (Columns)
        System.out.print("* ");
    }
    System.out.println(); // අලුත් පේළියකට යන්න
}

/* Output:
*
* *
* * *
* * * *
* * * * * */

6. Loop එක පාලනය කිරීම (Break & Continue) 🚦

සමහර වෙලාවට අපිට මැදදි Loop එක කඩන්න හරි, පැනලා යන්න හරි ඕන වෙනවා.

• break: Loop එක එතනම නවත්තලා එළියට පනිනවා. (Game Over වගේ).
• continue: පහළ තියෙන ටික නොකර, ආයේ උඩට ගිහින් ඊළඟ වටය පටන් ගන්නවා. (Skip කරනවා).

7. User ගෙන් Input ගැනීම සහ වැරදි දත්ත වලට අහු නොවී සිටීම 🛡️

Software එකක් වුනාම අපිට User ගෙන් දත්ත ගන්න වෙනවා (නම, වයස වගේ). Java වල මේකට පාවිච්චි කරන්නේ Scanner කියන Class එක.

අපිට මෙතන Import 2ක් ඕන වෙනවා:

• import java.util.Scanner;
  - මේකෙන් තමයි අපිට Keyboard එකෙන් දත්ත ගන්න පුළුවන් වෙන්නේ.
• import java.util.InputMismatchException;
  - මේක ගොඩක් අය දන්නේ නෑ. අපි ඉලක්කම් ඉල්ලද්දි User අකුරු ගැහුවොත් එන Error එක (ලෙඩේ) අල්ලගන්න නම්, මේක අනිවාර්යයෙන්ම Import කරන්න ඕනේ.

දැන් අපි බලමු කොහොමද Professional විදියට වැරදි Input එකක් ආවම Program එක කඩන් වැටෙන්නේ නැති වෙන්න හදන්නේ කියලා.

හැබැයි ප්‍රශ්නේ තියෙන්නේ, අපි වයස ඉල්ලුවම User "Twenty" කියලා අකුරු ගැහුවොත් මොකද වෙන්නේ? Program එක Crash වෙනවා. හොඳ Programmer කෙනෙක් ඒක නවත්වන්න ඕනේ. මේකට අපි Try-Catch Loop එකක් දාමු.

Pro Code: Bulletproof Input System (සම්පූර්ණ කෝඩ් එක)

මේ කෝඩ් එක කෙලින්ම Copy කරලා Run කරලා බලන්න. හරි ආසයි නේද?🤨 Type කරන්න Type කරන්න.

import java.util.Scanner; // 1. Scanner එක ගේනවා
import java.util.InputMismatchException; // Error අල්ලන එක ගේනවා

public class AgeValidator {
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in); // 2. Scanner එක හදනවා
        boolean valid = false; // කොඩියක් (Flag)

        System.out.println("--- Age Validator App ---");

        while (!valid) { // valid නැති තාක් කල් දුවන්න
            try {
                System.out.print("ඔයාගේ වයස කියන්න: ");
                int age = sc.nextInt(); // 3. Input ගන්නවා
                
                // Range Check (වයස 0-120 අතරද බලනවා)
                if (age > 0 && age < 120) {
                    System.out.println("සාර්ථකයි! වයස: " + age);
                    valid = true; // හරි ගියොත් Loop එකෙන් එළියට
                } else {
                    System.out.println("බොරු කියන්න එපා! හරි වයස දාන්න.");
                }
            } catch (InputMismatchException e) {
                System.out.println("⚠️ කරුණාකර ඉලක්කම් පමණක් ඇතුලත් කරන්න!");
                sc.next(); // වැරදි Input එක මෙමරියෙන් අයින් කරන්න (Clear Buffer)
            }
        }
        sc.close(); // වැඩේ ඉවර වුනාම Scanner එක වහන්න
    }
}

8. කෝඩ් එකේ වැරදි හොයන රහස් (Debugging) 🐞

කෝඩ් එකක් ගැහුවම ඒක වැඩ කරන්නේ නැත්නම් බය වෙන්න එපා. ලෝකේ දක්ෂම Programmer ලටත් වැරදි එනවා. ඒවා හොයාගන්න ප්‍රධාන ක්‍රම කිහිපයක් තියෙනවා.

ක්‍රමය 1: Rubber Duck Debugging 🦆 (විනෝදජනකම ක්‍රමය)

මේක Software Industry එකේ ප්‍රසිද්ධ රහසක්.

කොහොමද කරන්නේ?
1. මේසෙ උඩින් පොඩි රබර් තාරාවෙක් (හෝ වෙන බෝනික්කෙක්) තියාගන්න.
2. ඔයාගේ කෝඩ් එකේ පේළියෙන් පේළිය, ඒ තාරාවට සිංහලෙන් පැහැදිලි කරන්න.
3. "හරි තාරාවෝ, මේ පේළියෙන් වෙන්නේ x වල අගය වැඩි වෙන එක..."

පුදුම වැඩේ කියන්නේ, ඔයා මෙහෙම තනියම කියාගෙන යද්දි, ඔයාටම තේරෙනවා "අඩේ මම වැරදියිනේ කරලා තියෙන්නේ" කියලා!. උත්සාහ කරලා බලන්න. 😉

ක්‍රමය 2: Print Statements

කෝඩ් එකේ සැක හිතෙන තැන්වලට System.out.println("Checking Here 1"); වගේ කෑලි දාලා බලන්න කොතනින්ද වැඩේ නවතින්නේ කියලා.

අද ගෙදර වැඩ (Homework) 🏠

අපි ඉගෙන ගත්ත දේවල් වලින් මේ පොඩි අභ්‍යාසය කරන්න.

Task: ඉලක්කමක් දුන්නම (උදා: 7), ඒකේ චක්කරේ (Multiplication Table) 1 සිට 12 දක්වා Print කරන Program එකක් ලියන්න.

උත්තරේ පහළින් තියෙනවා. හැබැයි තනියම කරලා බලන්න! 😉

import java.util.Scanner;

public class MultiplicationTable {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("චක්කරේ ඕන අංකය දෙන්න: ");
        int number = sc.nextInt();

        System.out.println("--- " + number + " චක්කරේ ---");

        // 1 සිට 12 ට Loop වෙනවා
        for (int i = 1; i <= 12; i++) {
            int answer = number * i;
            System.out.println(number + " x " + i + " = " + answer);
        }
    }
}

ප්‍රශ්න තියෙනවා නම් පහළින් Comment කරන්න! KP Tech Gear සමඟ දිගටම රැඳී සිටින්න. 👇

ප්‍රශ්න තියෙනවා නම් පහළින් Comment කරන්න! KP Tech Gear සමඟ දිගටම රැඳී සිටින්න. 👇