Java Programming Sinhala - Part 05: The Java Toolkit (Operators, Casting & Scope) 🛠️

අපි මේ වෙනකොට Java වලින් සොෆ්ට්වෙයාර් එකක් හදන හැටි, තීරණ ගන්න හැටි (If/Else) සහ Loops ගැන ඉගෙන ගත්තා. හැබැයි "සුපිරි වැඩ්ඩෙක්" වෙන්න නම් අපිට තව පොඩි මෙවලම් කිහිපයක් ඕන වෙනවා. 🔧

අද අපි කතා කරන්නේ ගොඩක් Tutorials වල උඩින් පල්ලෙන් කියලා දුන්නට, ඇත්තටම සොෆ්ට්වෙයාර් එකක් වැඩ කරන විදිය තීරණය කරන ප්‍රධානම දේවල් 3ක් ගැනයි. ඒ තමයි Modulus Operator, Type Casting සහ Variable Scope. මේවා ඇත්තටම මොනවද? ඇයි මේවා පාවිච්චි කරන්නේ? මේවා නොදැන හිටියොත් මොකද වෙන්නේ? අපි සම්පූර්ණයෙන්ම බලමු. 🧐

1. Modulus Operator (%) - ඉතුරු ටික කෝ? 🍕

අපි සාමාන්‍යයෙන් බෙදීම (Division) කළාම අපිට ලැබෙන්නේ බෙදල එන උත්තරේ විතරයි. හැබැයි පරිගණක ලෝකයේදී "බෙදලා ඉතුරු වෙන ගාණ" (Remainder) කියන එක හරිම වැදගත්.

Java වල මේකට පාවිච්චි කරන්නේ % (Percent ලකුණ) එක. හැබැයි මේකෙන් Percent එකක් හොයන්නේ නෑ, මේකෙන් කරන්නේ බෙදලා ඉතුරු වෙන ගාණ දෙන එකයි.

සරල උදාහරණයක්:
ඔයා ගාව පීසා කෑලි 10ක් තියෙනවා. යාළුවෝ 3ක් ඉන්නවා.

• 10 / 3 = 3 (එක්කෙනෙක්ට කෑලි 3යි - මේක සාමාන්‍ය බෙදීම)
• 10 % 3 = 1 (බෙදුවට පස්සේ 1ක් ඉතුරුයි - මේක තමයි Modulus)

ඇයි අපිට "ඉතුරු වෙන ගාණ" වැදගත් වෙන්නේ? 🤔

නිකන්ම ගණන් හදන්න නෙමෙයි, ලෝකේ තියෙන ලොකුම Logic එකක් මේකෙන් විසඳනවා. ඒ තමයි ඔත්තේ/ඉරට්ටේ (Odd/Even) සංඛ්‍යා හොයන එක. ඕනෑම ඉරට්ටේ සංඛ්‍යාවක් 2න් බෙදුවම ඉතුරු වෙන්නේ 0 යි. ඉතුරු 1ක් ආවොත් ඒක ඔත්තේ සංඛ්‍යාවක්. මේ සම්පූර්ණ කෝඩ් එක Run කරලා බලන්න.

public class ModulusCheck {
    public static void main(String[] args) {
        int num = 10;

        // 2න් බෙදුවම ඉතුරු 0 ද බලනවා (එහෙමනම් ඒක ඉරට්ටේ)
        if (num % 2 == 0) {
            System.out.println(num + " යනු ඉරට්ටේ (Even) සංඛ්‍යාවකි."); 
        } else {
            System.out.println(num + " යනු ඔත්තේ (Odd) සංඛ්‍යාවකි.");
        }
    }
}

2. කෙටි ක්‍රම සහ පටලැවෙන තැන් (Increment & Decrement) ⚡

Software Engineers ලා කියන්නේ වැඩේ ඉක්මනට කරන්න කැමති කම්මැළියෝ පිරිසක් කියලා මම කලිනුත් කිව්වනේ😁😁. අපිට අගයක් එකකින් වැඩි කරන්න ඕන වුනාම (x = x + 1;) වගේ දිගට ලිය ලිය ඉන්න ඕන නෑ. ඒකට කෙටි ක්‍රම තියෙනවා.

• x++; (Postfix) - පස්සේ වැඩි කරන්න.
• ++x; (Prefix) - කලින් වැඩි කරන්න.

මේක පරිස්සමෙන්! ⚠️
මේ දෙකම තනියම තිබ්බොත් වැඩේ සමානයි. හැබැයි මේක වෙන Variable එකකට දාන්න ගියොත් ප්‍රතිඵලය සම්පූර්ණයෙන්ම වෙනස් වෙනවා. මේක ගොඩක් අය Interview වලදී වරද්දගන්න තැනක්.

සරලව මතක තියාගන්න:

• int a = x++; 👉 (පරණ අගය a ට දාන්න, ඊට පස්සේ x වැඩි කරන්න.) - හරියට Post Paid වගේ. බිල ගෙවන්නේ පස්සේ.
• int a = ++x; 👉 (මුලින්ම x වැඩි කරන්න, ඒ අලුත් අගය a ට දාන්න.) - හරියට Pre Paid වගේ. මුලින්ම ගෙවන්න ඕනේ.

මේ Code එක Run කරලා වෙනස තේරුම් ගන්න:

public class IncrementDifference {
    public static void main(String[] args) {
        
        // --- උදාහරණ 1: Postfix (x++) ---
        int x = 10;
        int result1 = x++; 
        // මෙතනදි result1 ට යන්නේ 10. (පස්සේ තමයි x 11 වෙන්නේ)
        
        System.out.println("x++ භාවිතා කළ විට:");
        System.out.println("Result අගය: " + result1); // 10
        System.out.println("x වල නව අගය: " + x);      // 11
        System.out.println("-----------------");

        // --- උදාහරණ 2: Prefix (++y) ---
        int y = 10;
        int result2 = ++y; 
        // මෙතනදි y මුලින්ම 11 වෙනවා. ඊට පස්සේ තමයි result2 ට යන්නේ.

        System.out.println("++y භාවිතා කළ විට:");
        System.out.println("Result අගය: " + result2); // 11
        System.out.println("y වල නව අගය: " + y);      // 11
    }
}

2.5 පරිගණකය ගණන් හදන පිළිවෙල (Operator Precedence) 🧮

අපි පුංචි කාලේ ගණිතයේදී ඉගෙන ගත්ත BODMAS නීතිය Java වලටත් අදාලයි. ඔයා නිකන්ම 5 + 10 * 2 කියලා ගැහුවොත් උත්තරේ 30 ද? 25 ද?

Java මුලින්ම කරන්නේ ගුණ කිරීමයි (Multiplication). ඊට පස්සේ තමයි එකතු කිරීම (Addition) කරන්නේ.

• 10 * 2 = 20
• 5 + 20 = 25 (උත්තරේ 25 යි) ✅

ඔයාට මුලින්ම එකතු කිරීම කරගන්න ඕන නම්, අනිවාර්යයෙන්ම වරහන් ( ) පාවිච්චි කරන්න ඕනේ. (5 + 10) * 2 කියලා දුන්නොත් උත්තරේ 30 වෙනවා. කෝඩ් ලියද්දි හැමවෙලේම වරහන් පාවිච්චි කරන එක හොඳ පුරුද්දක්.

3. Type Casting - බලහත්කාරයෙන් වර්ගය මාරු කිරීම 🔄

හිතන්න ඔයාට වතුර බාල්දියක් (double - ලොකුයි) තියෙනවා. ඒක කෝප්පයකට (int - පොඩියි) දාන්න පුළුවන්ද? බෑ නේද? වතුර හැලෙනවා. Java වලත් එහෙමයි.

Narrowing Casting (පරිස්සමෙන්!) ⚠️

double (දශම තියෙන) අගයක් int (පූර්ණ සංඛ්‍යා) වලට හරවද්දි දශම ටික (Data) නැති වෙනවා. Java මේක "ඉබේම" (Automatically) කරන්නේ නෑ, මොකද දත්ත මැකෙන නිසා. ඒක කරන්න ඕන නම් Programmer විසින් "බලහත්කාරයෙන්" කියන්න ඕනේ.

public class CastingDemo {
    public static void main(String[] args) {
        double myPrice = 9.99;
        
        // (int) කියලා දාලා අපි බලහත්කාරයෙන් Type එක මාරු කරනවා
        int myIntPrice = (int) myPrice; 

        System.out.println("මුල් ගාණ: " + myPrice);      // Output: 9.99
        System.out.println("Cast කළාට පස්සේ: " + myIntPrice);   // Output: 9 (දශම ටික කැපුනා!)
    }
}

4. Variable Scope - විචල්‍යයේ ආයු කාලය 🏠

මේක තමයි අලුත් අය වැඩිපුරම වරද්ද ගන්න තැන. Variable එකක් වැඩ කරන්නේ ඒක හදපු "Block" එක ඇතුලේ විතරයි. Block එකක් කියන්නේ සඟල වරහන් { } දෙකක් අතර තියෙන ප්‍රදේශයයි.

ඇයි මෙහෙම වෙන්නේ? (Memory Management) 🧠

අපි Variable එකක් හදනවා කියන්නේ RAM එකේ ඉඩක් වෙන් කරගන්නවා කියන එකනේ. අපි හදන හැම Variable එකම දිගටම RAM එකේ තිබ්බොත්, ටික වෙලාවකින් RAM එක පිරිලා Computer එක ස්ලෝ වෙනවා. ඒක නොවෙන්න තමයි Java විසින් "Scope එක ඉවර වුන ගමන්" ඒ Variable එක RAM එකෙන් මකලා දාන්නේ (Garbage Collection). ඒකයි එළියට ආවම ඒක පාවිච්චි කරන්න බැරි.

සරල උදාහරණයක්:
ඔයා කාමරයක් ඇතුලේ (If Condition) පුටුවක් තිබ්බොත්, ඒක සාලේ ඉන්න කෙනෙක්ට (Main Method) පේන්නේ නෑ.

public class ScopeTest {
    public static void main(String[] args) {
        
        // මේක මුළු ගෙදරටම අයිතියි (Main Scope)
        int x = 100; 

        if (x == 100) {
            // මේ y අයිති මේ කාමරේට (Block) විතරයි
            int y = 20; 
            System.out.println("ඇතුලේ එකතුව: " + (x + y)); // වැඩ කරනවා ✅
        }

        // System.out.println(y); 
        // ❌ Error! මෙතනදි y කියලා කෙනෙක්ව අඳුරන්නේ නෑ. මොකද y දැන් මැරිලා ඉවරයි (Removed from Memory).
    }
}

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

අපි අද ඉගෙන ගත්ත දේවල් එකතු කරලා මේක කරන්න.

Task:
1. 1 සිට 20 දක්වා Loop එකක් දුවන්න.
2. හැම ඉලක්කමක්ම 3න් බෙදුවම ඉතුරු වෙන ගාණ (Modulus) හොයන්න.
3. ඉතුරු වෙන ගාණ 0 නම් "බෙදෙනවා" කියලත්, නැත්නම් "ඉතුරුයි" කියලත් Print කරන්න.

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

public class ModulusChallenge {
    public static void main(String[] args) {
        System.out.println("--- 3න් බෙදෙන සංඛ්‍යා සෙවීම ---");

        for (int i = 1; i <= 20; i++) {
            // 3න් බෙදුවම ඉතුරු 0 ද බලනවා
            if (i % 3 == 0) {
                System.out.println(i + " : 3න් බෙදෙනවා ✅");
            } else {
                System.out.println(i + " : බෙදෙන්නේ නෑ (ඉතුරු: " + (i % 3) + ")");
            }
        }
    }
}

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