Java Sinhala - Part 09: OOP වල සැඟවුණු රහස්! (Memory, Modifiers & Deep Dive) 🧠🛠️

කලින් Part 08 එකෙන් අපි OOP ලෝකයට අඩිය තිබ්බා විතරයි. Class එකක් කියන්නේ ප්ලෑන් එකක් (Blueprint) කියලත්, Object එකක් කියන්නේ ඒ ප්ලෑන් එකෙන් හදන ඇත්තම දේ කියලත් අපි ඉගෙන ගත්තා. හැබැයි Software Engineering පන්තියකදී නම් ඔය ටික දැනගෙන මදි.

පිටින් බලද්දි පේන කෝඩ් එකට වඩා, කෝඩ් එක Run වෙද්දි Computer එකේ RAM එක ඇතුලේ මොකද වෙන්නේ? public, private වගේ වචන වල තේරුම මොකක්ද? අන්න ඒ යටිකූට්ටු වැඩ ටික (Under the hood mechanics) තමයි අද අපි ගැඹුරටම හාරලා බලන්නේ. මේක හරියටම Campus එකක දෙන සම්පූර්ණ Lecture මොඩියුල් එකක් වගේ තමයි මම ලෑස්ති කරලා තියෙන්නේ. ලෑස්තිද? එහෙනම් පටන් ගමු! 🚀

1. Memory Management: RAM එක ඇතුලේ Objects හැදෙන හැටි 🧠

අපි Object එකක් හදද්දි ලියන කෝඩ් එක මතකද? SmartPhone p1 = new SmartPhone();. මේ පේළිය ලිව්වම Computer එකේ Memory එක (RAM එක) ඇතුලේ මොකද වෙන්නේ කියලා දන්නවද? Java වල ප්‍රධාන Memory කොටස් දෙකක් තියෙනවා: Stack Memory සහ Heap Memory.

📦 Stack vs Heap (මතක තබාගන්නම ඕන දෙයක්)

• Stack Memory: මේක හරියට ඔයාගේ සාක්කුව වගේ. පොඩි දේවල් තමයි දාන්නේ. අපි හදන Variables (උදා: int a = 10;) සහ Object එකේ නම (Reference/Pointer එක) හැදෙන්නේ මෙතනයි. ඒ කියන්නේ අර p1 කියන නම තියෙන්නේ Stack එකේ.
• Heap Memory: මේක හරියට ලොකු ගබඩාවක් (Warehouse) වගේ. අපි new කියන වචනේ පාවිච්චි කළාම, ඒ ලොකු Object එක (අර රැම් එක, පාට, බ්‍රෑන්ඩ් එක ඔක්කොම තියෙන ලොකු ෆෝන් එක) හැදෙන්නේ මේ Heap එක ඇතුලෙයි.

සම්බන්ධය: Stack එකේ තියෙන p1 කියන Variable එකෙන් කරන්නේ, Heap එකේ හැදිලා තියෙන ලොකු Object එක ඉන්නේ කොතනද කියලා ඇඟිල්ල දික් කරලා පෙන්නන එක (Pointing) විතරයි. හරියට TV රිමෝට් එකයි, TV එකයි වගේ! p1 කියන්නේ රිමෝට් එක.

පොඩි ප්‍රශ්නයක්: අපි SmartPhone p2 = p1; කියලා ලිව්වොත් අලුත් ෆෝන් එකක් (Object එකක්) හැදෙනවද?
උත්තරය: නෑ! එතනදි වෙන්නේ එකම TV එකට තව රිමෝට් එකක් (p2) හැදෙන එක විතරයි. p1 න් පාට වෙනස් කළොත්, p2 ටත් පේන්නේ අලුත් පාටම තමයි. මේ සංකල්පය තේරුම් ගන්න එක ගොඩක් වැදගත්!

2. Constructors: ගැඹුරු හැදෑරීමක් 🏗️

කලින් කොටසේදී අපි Constructor එකක් ගැන කතා කළා. Constructor එකක් කියන්නේ Object එකක් "උපදින මොහොතේම" Run වෙන විශේෂ Method එකක්. හැබැයි මේකේ අපි කතා නොකරපු තව ලොකු රහස් ටිකක් තියෙනවා.

2.1 Default Constructor (නොපෙනෙන Constructor එක)

හිතන්න ඔයා Class එක ඇතුලේ කිසිම Constructor එකක් ලිව්වේ නෑ කියලා. එතකොට Object එකක් හැදෙන්නේ කොහොමද? Java මාර Smart. ඔයා Constructor එකක් ලිව්වේ නැත්නම්, Java Compiler එක විසින් ඉබේම හිස් Constructor එකක් (Default Constructor) එතනට දානවා.

class Student {
    String name;
    // අපි මෙතන Constructor එකක් ලිව්වේ නෑ...
}

public class Main {
    public static void main(String[] args) {
        // ඒත් අපිට Object එක හදන්න පුළුවන්! (Java ඉබේම Default එකක් හදපු නිසා)
        Student s1 = new Student();
    }
}

2.2 Constructor Overloading (එකම නම, විවිධ වැඩ)

අපිට එකම Class එක ඇතුලේ Constructors කිහිපයක් හදන්න පුළුවන්. මේකට කියන්නේ Constructor Overloading කියලා. මේක ගොඩක් වැදගත් වෙන්නේ අපිට විවිධ විදියට Objects හදන්න ඕන වුනාමයි. (සමහර අයට විස්තර ඔක්කොම තියෙනවා, සමහර අයට නම විතරයි තියෙන්නේ).

class Laptop {
    String brand;
    int ram;

    // Constructor 1: කිසිම විස්තරයක් නොදී ලැප් එක හැදුවොත් (No-Arg Constructor)
    public Laptop() {
        this.brand = "Unknown";
        this.ram = 4; // අවම RAM එක
    }

    // Constructor 2: බ්‍රෑන්ඩ් එකයි රැම් එකයි දෙකම දීලා හැදුවොත් (Parameterized)
    public Laptop(String brand, int ram) {
        this.brand = brand;
        this.ram = ram;
    }
}

🚨 රන් නීතිය: ඔයා එක Parameterized Constructor එකක් හරි ලිව්වොත්, අර Java වලින් නිකන් දෙන Default Constructor එක මැකිලා යනවා. ඊට පස්සේ හිස් වරහන් දාලා new Laptop() කියලා Object එකක් හදන්න ගියොත් Error එකක් එනවා (ඔයා ආයේ අතින්ම හිස් Constructor එකක් ලියනකම්).

3. Access Modifiers: දත්ත වල ආරක්ෂකයින් 🛡️

මෙච්චර කල් අපි හැමදේටම ඉස්සරහින් public කියලා දැම්මා නේද? හැබැයි ඇත්තම Software එකක් හදද්දි එහෙම කරන්න බෑ. බැංකු ගිණුමක (Bank Account) කෝඩ් එකක් ලියද්දි, Account Balance එක ඕනම කෙනෙකුට වෙනස් කරන්න පුළුවන් විදියට public කරලා තිබ්බොත් මොකද වෙන්නේ? පිස්සු හැදෙනවනේ!

අන්න ඒ නිසා Java වල අපේ දත්ත ආරක්ෂා කරන්න Access Modifiers ජාති 4ක් තියෙනවා.

1. 🟢 public: ඕනෑම කෙනෙකුට, ඕනෑම තැනක ඉඳන් (වෙන Class එකකින්, වෙන Package එකකින්) මේක පාවිච්චි කරන්න පුළුවන්. කිසිම තහනමක් නෑ.
2. 🔴 private: මේක තමයි ලොකුම සෙකියුරිටි එක. Private දැම්මොත්, ඒ Variable එක හරි Method එක හරි පාවිච්චි කරන්න පුළුවන් ඒ Class එක ඇතුලේ අයට විතරයි! වෙන කිසිම Class එකකට මේක පේන්නේ නෑ.
3. 🟡 protected: මේක අදාල වෙන්නේ Inheritance (උරුමය) පාඩමේදී. මේකෙන් කරන්නේ තමන්ගේ පවුලේ අයට (Child classes) සහ තමන්ගේ Package එකේ අයට විතරක් පාවිච්චි කරන්න දෙන එක.
4. ⚪ default (කිසිවක් නොලියා සිටීම): ඉස්සරහින් මුකුත්ම ලිව්වේ නැත්නම්, ඒක අයිති වෙන්නේ Default එකට. එතකොට ඒ Package එක (ෆෝල්ඩරය) ඇතුලේ තියෙන අයට විතරක් ඒක පාවිච්චි කරන්න පුළුවන්.

4. Getters සහ Setters (Private දත්ත එළියට ගන්න දොරවල්) 🚪

හරි, දැන් අපි අපේ බැංකු ගිණුමේ සල්ලි private කළා කියමුකෝ. එතකොට වෙන Class එකක ඉන්න කෙනෙකුට තමන්ගේ සල්ලි කොච්චර තියෙනවද කියලා බලාගන්නවත් විදියක් නෑනේ. අන්න ඒකට අපි විශේෂ Methods ජාතියක් පාවිච්චි කරනවා.

• Getters: Private දත්තයක් එළියට "කියවන්න" (Read) දෙන Method එක.
• Setters: Private දත්තයක් ආරක්ෂිතව "වෙනස් කරන්න" (Update) දෙන Method එක.

මේකට OOP වල කියන ලොකු නම තමයි Encapsulation (දත්ත සැඟවීම). මේක අපි ඊළඟ පාඩමෙන් තව ගැඹුරට කතා කරනවා. දැනට කෝඩ් එක බලන්නකෝ.

class BankAccount {
    // 1. Variable එක private කරනවා (කෙලින්ම සල්ලි අතගාන්න බෑ)
    private double balance;

    public BankAccount(double initialMoney) {
        this.balance = initialMoney;
    }

    // 2. Getter Method එක (සල්ලි ගාන බලාගන්න විතරයි පුළුවන්)
    public double getBalance() {
        return this.balance;
    }

    // 3. Setter Method එක (කොන්දේසි දාලා සල්ලි වෙනස් කරන්න දෙනවා)
    public void depositMoney(double amount) {
        if (amount > 0) { // සෘණ ගණන් දාන්න බෑ! මෙන්න සෙකියුරිටි!
            this.balance = this.balance + amount;
            System.out.println("සල්ලි දැම්මා!");
        } else {
            System.out.println("හොරා කන්න බෑ!");
        }
    }
}

5. The `static` Keyword: හැමෝටම පොදු දේවල් 🌍

මෙන්න ගොඩක් අය පටලගන්න තැනක්. අපි හිතමු අපි Campus එකේ (උදාහරණයක් විදියට IIT එකේ) ළමයි ලියාපදිංචි කරන Software එකක් හදනවා (Student Management System). එක ළමයෙක්ට Object එක ගානේ හදනවා. කමල්ගේ නම 'කමල්', නිමල්ගේ නම 'නිමල්'. හැබැයි මේ දෙන්නගෙම "University Name" එක සමානයි නේද?

ළමයි 1000ක් හිටියොත් අර universityName = "IIT" කියන එක 1000 පාරක් Memory (RAM) එකේ සේව් වෙනවා. ඒක මාර අපරාධයක්! අන්න ඒකට තමයි static කියන මැජික් වචනේ තියෙන්නේ.

💡 Static කියන්නේ කුමක්ද?
යම් Variable එකක් හෝ Method එකක් ඉස්සරහින් static කියලා දැම්මොත්, ඒක අයිති වෙන්නේ Object එකට නෙමෙයි, මුළු Class එකටමයි! ඒ කියන්නේ RAM එකේ ඒක සේව් වෙන්නේ එක පාරයි. ළමයි 1000ක් හිටියත්, ඒ 1000 දෙනාම ශෙයාර් (Share) කරගන්නේ අර එකම Static Variable එකයි.

class Student {
    String name; // එක එක්කෙනාට වෙනස් (Instance Variable)
    static String university = "IIT"; // හැමෝටම එකයි! (Class Variable)

    public Student(String n) {
        this.name = n;
    }
}

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student("Kamal");
        Student s2 = new Student("Nimal");

        // Static ඒවට කතා කරන්නේ Object එකේ නමෙන් නෙමෙයි, Class එකේ නමෙන්මයි!
        System.out.println(s1.name + " ඉගෙන ගන්නේ " + Student.university);
    }
}

(ඔන්න දැන් ඔයාට තේරෙනවා ඇති ඇයි අපි හැමදාම public static void main කියලා ලියන්නේ කියලා. Main method එකට static දාන්නේ, Object එකක් හදන්න කලින්ම මුළු ප්‍රෝග්‍රෑම් එකම පටන් ගන්න ඕන නිසයි!)

6. Garbage Collector: Java වල කුණු අදින රථය 🚛🧹

C++ වගේ පරණ භාෂා වල කෝඩ් ලියද්දි, අපි Object එකක් හැදුවොත් අන්තිමට ඒක මකලා Memory එක (RAM එක) නිදහස් කරන්න කෝඩ් එකකුත් ලියන්න ඕනේ. නැත්නම් Memory පිරිලා Computer එක හිරවෙනවා (Memory Leak).

හැබැයි Java වල තියෙන ලොකුම වාසිය තමයි Garbage Collector (GC). මේක ඉබේම දුවන පොඩි ප්‍රෝග්‍රෑම් එකක්. මේකෙන් කරන්නේ Heap Memory එකේ තියෙන, හැබැයි කිසිම Stack Variable එකකින් (රිමෝට් එකකින්) ඇඟිල්ල දික් කරලා නැති "අනාථ වුණු" Objects හොයාගෙන ගිහින් ඒවා මකලා දාන එකයි.

SmartPhone p1 = new SmartPhone(); // Object එක හැදුනා
p1 = null; // අපි රිමෝට් එකේ කනෙක්ෂන් එක කැඩුවා (p1 වලට මුකුත් නෑ)

// දැන් අර හැදුණු SmartPhone Object එකට කතා කරන්න කවුරුත් නෑ.
// තව ටිකකින් Garbage Collector ඇවිත් ඒ Object එක RAM එකෙන් මකලා දානවා! 🧹

---

Mega Project: University Student System 🎓💻

අද ඉගෙන ගත්ත Constructors, Private variables, Getters/Setters සහ Static keywords ඔක්කොම එකතු කරලා අපි සම්පූර්ණ Class එකක් ලියමු.

class CampusStudent {
    // 1. Static Variable (හැමෝටම පොදුයි)
    public static String university = "IIT Sri Lanka";

    // 2. Private Variables (ආරක්ෂිතයි)
    private String studentName;
    private double gpa;

    // 3. Constructor එක
    public CampusStudent(String name, double gpa) {
        this.studentName = name;
        this.setGPA(gpa); // Setter එක හරහාම දත්තය දානවා (ආරක්ෂාවට)
    }

    // 4. Getter Method එක
    public String getName() {
        return this.studentName;
    }

    // 5. Setter Method එක (GPA එක 0-4 අතර විතරයි තියෙන්න පුළුවන්)
    public void setGPA(double newGPA) {
        if (newGPA >= 0.0 && newGPA <= 4.0) {
            this.gpa = newGPA;
        } else {
            System.out.println("❌ Error: GPA එක 0 ත් 4 ත් අතර වෙන්න ඕනේ!");
        }
    }

    public void showDetails() {
        System.out.println("🎓 Name: " + studentName + " | GPA: " + gpa + " | Uni: " + university);
    }
}

public class Main {
    public static void main(String[] args) {
        CampusStudent s1 = new CampusStudent("Kaweesha", 3.8);
        s1.showDetails();

        // s1.gpa = 5.0; // ❌ මේක කරන්න බෑ! gpa කියන්නේ private දෙයක්.
        s1.setGPA(5.0); // ❌ Setter එකෙන් Error එකක් දෙනවා හොර කරන්න ගියාම.
    }
}

🎯 සාරාංශය: දැන් ඔයා දන්නවා Object එකක් හැදෙන්නේ Heap එකේ කියලා. Constructor එකෙන් ඒක මුලින්ම Setup කරනවා. private වලින් දත්ත හංගනවා. getters/setters වලින් ඒවට පාලනයක් දෙනවා. static වලින් මුළු Class එකටම පොදු දේවල් හදනවා.

ඊළඟ කොටසින්: OOP වල රහස් බලවේග 4 න් පළමුවැන්න! (Encapsulation සහ Inheritance) 🛡️🧬
දිගටම KP Tech Gear සමඟ රැඳී සිටින්න! 👇