Java Sinhala - Part 10: OOP වල රහස් බලවේග! (Encapsulation & Inheritance) 🛡️🧬

Software Engineering ලෝකයේ ඔයා කොයිම භාෂාවක් ඉගෙන ගත්තත් (Java, C#, Python) ඔයා අනිවාර්යයෙන්ම දැනගෙන ඉන්න ඕන ලොකුම සංකල්පය තමයි OOP (Object-Oriented Programming). මේ OOP කියන කූඩාරම රඳා පවතින්නේ ප්‍රධාන කණු (Pillars) 4ක් මතයි.

1. Encapsulation (දත්ත සැඟවීම)
2. Inheritance (උරුමය)
3. Polymorphism (බහුරූපීතාව)
4. Abstraction (වියුක්ත කිරීම)

අද අපි මේකෙන් මුල්ම රහස් බලවේග දෙක වන Encapsulation සහ Inheritance කියන්නේ මොකක්ද කියලා, අපේ ප්‍රායෝගික Project උදාහරණත් එක්කම බලමු!

🛡️ 1. Encapsulation (දත්ත සැඟවීම සහ ආරක්ෂා කිරීම)

මේ වචනේ ඇතුලෙම තියෙනවා "Capsule" (කරල) කියන වචනේ. බෙහෙත් කරලක් දිහා බැලුවොත් ඇතුලේ තියෙන තිත්ත බෙහෙත් කුඩු ටික අපිට පේන්නේ නෑ. ඒක වටේට ලස්සන ආවරණයක් තියෙනවා. Encapsulation කියන්නෙත් අන්න ඒ වගේ දෙයක්!

💡 Encapsulation යනු:
අපේ Class එක ඇතුලේ තියෙන වැදගත් Variables (දත්ත), පිටින් ඉන්න අයට කෙලින්ම වෙනස් කරන්න බැරි වෙන්න private කරලා හංගන එක. ඊට පස්සේ ඒ දත්ත වෙනස් කරන්න ඕනේ නම් අපි ආරක්ෂිත දොරවල් (Getters සහ Setters) හදලා දෙනවා. අපි Part 09 එකේ කතා කරපු දේම තමයි මේ!

🎮 උදාහරණය: Stickman Combat Game එකක්!

හිතන්න ඔයා 2D Mobile Game එකක් හදනවා කියලා. මේකේ Player ගේ Health (ජීවය) එක තියෙනවා. අපි මේ Health එක public කරලා තිබ්බොත්, ඕනම කෙනෙකුට (Hackers ලට) කෙලින්ම player.health = 9999; කියලා වෙනස් කරලා ගේම් එක හොර කරන්න පුළුවන්. Encapsulation වලින් අපි ඒක නතර කරනවා.

class StickmanPlayer {
    // 1. දත්තය private කරලා හැංගුවා (කාටවත් කෙලින්ම අල්ලන්න බෑ)
    private int health = 100;

    // 2. Getter (Health එක බලාගන්න විතරක් දෙනවා)
    public int getHealth() {
        return health;
    }

    // 3. Setter (Health එක වෙනස් කරන්න දෙන ආරක්ෂිත දොර)
    public void takeDamage(int damage) {
        if (damage > 0 && damage <= 100) {
            health = health - damage;
            if(health < 0) health = 0;
        } else {
            System.out.println("⚠️ Invalid Damage Amount!");
        }
    }
}

දැන් දැක්කා නේද? අපේ කෝඩ් එක මාරම ආරක්ෂිතයි. මේකට තමයි Encapsulation කියලා කියන්නේ!

🧬 2. Inheritance (උරුමය සහ කෝඩ් නැවත භාවිතය)

මේක තමයි OOP වල තියෙන ලස්සනම සංකල්පය. "උරුමය" කිව්වම ඔයාට මතක් වෙන්නේ මොකක්ද? තාත්තාගෙන් පුතාට දේවල් (ඉඩකඩම්, පෙනුම) උරුම වෙනවා නේද? Programming වලදිත් ඒක එහෙම්මමයි!

💡 Inheritance යනු:
එක Class එකක (Parent Class) තියෙන Variables සහ Methods, තවත් අලුත් Class එකකට (Child Class) මුල ඉඳන් ලියන්නේ නැතුව කෙලින්ම උරුම කරගන්න එකයි. මේකට අපි පාවිච්චි කරන්නේ extends කියන keyword එකයි.

🎓 උදාහරණය: University Management System එකක්!

හිතන්න Campus එකක System එකක් හදනවා. ඒකේ UndergradStudent (සාමාන්‍ය සිසුවා) සහ ComputerScienceStudent (CS කරන සිසුවා) කියලා ජාති දෙකක් ඉන්නවා. හැමෝටම නමක්, වයසක් තියෙනවනේ. අපි ඒක හැම Class එකේම ලිය ලිය ඉන්නවද? නෑ! අපි ප්‍රධාන Class එකක් හදලා ඒක අනිත් අයට උරුම කරලා දෙනවා.

// 1. Parent Class (තාත්තා - Base Class)
class Student {
    public String name;
    public int age;

    public void study() {
        System.out.println(name + " is studying...");
    }
}

// 2. Child Class (පුතා - Sub Class) | "extends" keyword එක බලන්න!
class CSStudent extends Student {
    // මේක ඇතුලේ නම, වයස ආයේ ලියන්න ඕනේ නෑ! ඒක උරුම වෙලා ඉවරයි.
    public String programmingLanguage;

    public void writeCode() {
        System.out.println(name + " is coding in " + programmingLanguage);
    }
}

// 3. Main Class එකේ වැඩ කරන හැටි
public class Main {
    public static void main(String[] args) {
        CSStudent myStudent = new CSStudent();
        
        // Parent ගෙන් ආපු දේවල් පාවිච්චි කරනවා
        myStudent.name = "Kaweesha";
        myStudent.age = 22;
        myStudent.study(); // Output: Kaweesha is studying...

        // තමන්ගේ දේවල් පාවිච්චි කරනවා
        myStudent.programmingLanguage = "Java";
        myStudent.writeCode(); // Output: Kaweesha is coding in Java
    }
}

⚠️ වැදගත්: Java වල Multiple Inheritance බෑ!
එක පුතෙකුට තාත්තලා දෙන්නෙක් ඉන්න බෑනේ. අන්න ඒ වගේම Java වල එක Class එකකට extends කරලා Classes දෙකකින් දේවල් උරුම කරගන්න බෑ (C++ වල මේක පුළුවන්). ඒකට අපි පාවිච්චි කරන්නේ Interfaces කියන වෙනම ක්‍රමයක් (ඒ ගැන පස්සේ කතා කරමු).

🌟 Inheritance වල තියෙන ලොකුම වාසිය

Code Reusability (කෝඩ් එක නැවත නැවත භාවිතය): එකම කෝඩ් එක වටේ යව යව ලියන්නේ නැතුව එක තැනක ලිව්වම, ඒක ඕනම Child Class එකකට අරගන්න පුළුවන්. මේකෙන් අපේ කෝඩ් එක පිරිසිදු වෙනවා, Time එක සෑහෙන්න ඉතුරු වෙනවා.

ඊළඟ කොටසින්: OOP වල ඉතුරු රහස් බලවේග 2! (Polymorphism සහ Abstraction) 🎭👻
දිගටම KP Tech Gear සමඟ රැඳී සිටින්න! 👇