Java Inheritance: පරම්පරාවෙන් දේවල් ගන්න හැටි - SC Guide

කෝමද ඉතින් යාළුවනේ! අද අපි කතා කරන්නේ Java වල තියෙන හරිම වැදගත් සහ රසවත් concept එකක් ගැන – ඒ තමයි Inheritance.

OOP (Object-Oriented Programming) වලදී Inheritance කියන්නේ නැතුවම බැරි දෙයක්. හිතන්නකෝ, අපේ පවුල්වල දේවල් පරම්පරාවෙන් පරම්පරාවට එනවා වගේ, programming වලදීත් අපිට පුළුවන් එක class එකක තියෙන දේවල් (properties & methods) තව class එකකට දෙන්න. ඒක කොච්චර ලේසිද නේද වැඩ කරන්න?

අද මේ ලිපියෙන් අපි Inheritance කියන්නේ මොකක්ද, ඒකෙන් අපිට ලැබෙන වාසි මොනවද, Practical විදිහට කොහොමද මේක පාවිච්චි කරන්නේ කියලා සරලවම කතා කරමු. එහෙනම් වැඩේට බහිමු!

Inheritance කියන්නේ මොකක්ද?

සරලවම කිව්වොත්, Inheritance කියන්නේ Java වල තියෙන OOP concept එකක්. මේකෙන් වෙන්නේ එක class එකක තියෙන attributes (variables) සහ behaviors (methods) තව class එකකට පාවිච්චි කරන්න (inherit කරන්න) පුළුවන් වෙන එකයි. මේකෙන් අපේ code එක නැවත නැවත ලියන එක (code duplication) අඩු කරගන්න පුළුවන්, ඒ වගේම code එක maintain කරන්නත් හරිම ලේසියි.

Inheritance වලදී class දෙකක් තියෙනවා:

• Parent Class (Super Class / Base Class): මේක තමයි මුලින්ම තියෙන class එක. මේ class එකේ තියෙන properties සහ methods තමයි අනිත් class වලට inherit කරන්නේ.
• Child Class (Sub Class / Derived Class): මේක තමයි Parent Class එකේ properties සහ methods inherit කරන class එක. Child class එකකට පුළුවන් Parent class එකේ දේවල් පාවිච්චි කරන්න, ඒ වගේම තමන්ටම ආවේණික අලුත් දේවල් (new properties & methods) එකතු කරන්නත්.

Java වලදී Inheritance implement කරන්න අපි extends කියන keyword එක පාවිච්චි කරනවා. උදාහරණයක් විදිහට, Car කියන class එක Vehicle කියන class එකෙන් inherit කරනවා නම්, අපි ලියන්නේ මෙහෙමයි:

class Car extends Vehicle {
    // Car class එකට අදාල properties සහ methods
}

Inheritance වලින් අපිට මොනවද ලැබෙන්නේ?

Inheritance පාවිච්චි කරන එකෙන් අපිට ගොඩක් වාසි ලැබෙනවා. ඒවා තමයි:

1. Code Reusability (Code නැවත පාවිච්චි කිරීම)

මේක තමයි Inheritance වල ප්‍රධානම වාසිය. හිතන්න, අපිට Vehicle වර්ග කීපයක් (Car, Motorbike, Bus) තියෙනවා කියලා. මේ හැම Vehicle එකකටම startEngine(), stopEngine() වගේ common methods තියෙනවා. අපි මේ methods හැම class එකකම වෙන වෙනම ලියනවා වෙනුවට, Vehicle කියන Parent class එකක් හදලා ඒකේ මේ common methods ටික ලියලා, අනිත් Child classes වලට (Car, Motorbike, Bus) ඒක inherit කරන්න පුළුවන්. එතකොට අපිට code නැවත නැවත ලියන්න ඕනේ නැහැ, වෙලාවත් ඉතුරුයි.

2. Method Overriding (Methods overwrite කිරීම)

Method Overriding කියන්නේ Parent class එකේ තියෙන method එකක් Child class එකකදී තමන්ට ඕන විදිහට වෙනස් කරලා ලියන එකට. උදාහරණයක් විදිහට, Vehicle class එකේ startEngine() method එකක් තියෙනවා නම්, Car class එකට පුළුවන් ඒ method එක තමන්ට ආවේණික විදිහට (car එකක engine එක start වෙන විදිහට) override කරන්න. මේක ගැන අපි Polymorphism කතා කරනකොට තවත් හොඳට ඉගෙනගමු.

3. Polymorphism (විවිධ ආකාරවලට හැසිරීම)

Inheritance නිසා Polymorphism කියන concept එකටත් පදනම ලැබෙනවා. Polymorphism කියන්නේ එකම method එකක් විවිධ object වර්ග වලට අනුව වෙනස් විදිහට ක්‍රියාත්මක වෙන එකට. මේක ගැන ගැඹුරින්ම වෙනම ලිපියකින් කතා කරන්න පුළුවන්. අදට මේකෙන් ලැබෙන වාසියක් විතරක් කියලා මතක තියාගමු.

ප්‍රායෝගික උදාහරණයක්

හරි, දැන් අපි theory ඇති. අපි code එකක් ලියලාම බලමු මේක වැඩ කරන්නේ කොහොමද කියලා. අපි Vehicle එකක උදාහරණයම ගමු.

මුලින්ම, අපේ Parent class එක, Vehicle class එක හදමු.

// Vehicle.java
class Vehicle {
    String make;
    String model;
    int year;

    public Vehicle(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;
        System.out.println("Vehicle constructor called.");
    }

    public void startEngine() {
        System.out.println(make + " " + model + " engine started.");
    }

    public void stopEngine() {
        System.out.println(make + " " + model + " engine stopped.");
    }

    public void displayInfo() {
        System.out.println("Make: " + make + ", Model: " + model + ", Year: " + year);
    }
}

දැන් අපි මේ Vehicle class එකෙන් inherit කරන Child classes දෙකක් හදමු: Car සහ Motorbike.

මුලින්ම, Car class එක.

// Car.java
class Car extends Vehicle {
    int numberOfDoors;

    public Car(String make, String model, int year, int numberOfDoors) {
        // Parent class එකේ constructor එකට values යවනවා
        super(make, model, year); 
        this.numberOfDoors = numberOfDoors;
        System.out.println("Car constructor called.");
    }

    public void drive() {
        System.out.println(make + " " + model + " is driving with " + numberOfDoors + " doors.");
    }

    // Method Overriding වලට උදාහරණයක්
    @Override
    public void startEngine() {
        System.out.println(make + " " + model + " starting engine with a turn of the key.");
    }
}

ඊළඟට, Motorbike class එක.

// Motorbike.java
class Motorbike extends Vehicle {
    boolean hasSideCar;

    public Motorbike(String make, String model, int year, boolean hasSideCar) {
        super(make, model, year);
        this.hasSideCar = hasSideCar;
        System.out.println("Motorbike constructor called.");
    }

    public void wheelie() {
        String sideCarStatus = hasSideCar ? "with a sidecar" : "without a sidecar";
        System.out.println(make + " " + model + " is doing a wheelie " + sideCarStatus + "!");
    }
}

දැන් අපි මේ classes ටික පාවිච්චි කරලා බලමු.

// Main.java
public class Main {
    public static void main(String[] args) {
        System.out.println("----------------- Creating Car Object -----------------");
        Car myCar = new Car("Toyota", "Corolla", 2020, 4);
        myCar.displayInfo(); // Vehicle class එකෙන් inherit කරපු method එකක්
        myCar.startEngine(); // Overridden method in Car class
        myCar.drive(); // Car class එකට ආවේණික method එකක්
        myCar.stopEngine(); // Vehicle class එකෙන් inherit කරපු method එකක්

        System.out.println("\n----------------- Creating Motorbike Object -----------------");
        Motorbike myMotorbike = new Motorbike("Honda", "CBR", 2022, false);
        myMotorbike.displayInfo(); // Vehicle class එකෙන් inherit කරපු method එකක්
        myMotorbike.startEngine(); // Vehicle class එකෙන් inherit කරපු method එකක් (මෙතන override වෙලා නෑ)
        myMotorbike.wheelie(); // Motorbike class එකට ආවේණික method එකක්
        myMotorbike.stopEngine(); // Vehicle class එකෙන් inherit කරපු method එකක්
    }
}

Output:

----------------- Creating Car Object -----------------
Vehicle constructor called.
Car constructor called.
Make: Toyota, Model: Corolla, Year: 2020
Toyota Corolla starting engine with a turn of the key.
Toyota Corolla is driving with 4 doors.
Toyota Corolla engine stopped.

----------------- Creating Motorbike Object -----------------
Vehicle constructor called.
Motorbike constructor called.
Make: Honda, Model: CBR, Year: 2022
Honda CBR engine started.
Honda CBR is doing a wheelie without a sidecar!
Honda CBR engine stopped.

හිතාගන්න පුළුවන් නේද? Car සහ Motorbike objects දෙකටම displayInfo(), startEngine(), stopEngine() කියන methods ලැබුණේ Vehicle class එකෙන්. ඒ වගේම Car එකට තියෙන drive() method එකයි, Motorbike එකට තියෙන wheelie() method එකයි ඒ class වලටම ආවේණික දේවල්. ඒ වගේම Car එකේ startEngine() method එක override වෙලා තියෙන හැටිත් පේනවා.

මතක තියාගන්න ඕන වැදගත් දේවල්

• Multiple Inheritance නැහැ: Java වලදී එක class එකකට පුළුවන් වෙන්නේ එක Parent class එකකින් විතරක් inherit කරන්න. ඒ කියන්නේ class A extends B, C { ... } වගේ ලියන්න බැහැ. (Interfaces පාවිච්චි කරලා මේ වගේ දේවල් කරන්න පුළුවන් වුණත්, classes වලට මේ පහසුකම නැහැ.)
• Constructors inherit වෙන්නේ නැහැ: Parent class එකේ constructors Child class එකට inherit වෙන්නේ නැහැ. ඒත්, Child class එකක් object එකක් හදනකොට Parent class එකේ constructor එකක් අනිවාර්යයෙන්ම call වෙනවා. ඒකට අපි super() කියන keyword එක පාවිච්චි කරනවා. මේක හැම විටම Child class constructor එකේ පළවෙනි statement එක විය යුතුයි.
• private members inherit වෙන්නේ නැහැ: Parent class එකේ private access modifier එකෙන් define කරපු methods හෝ variables Child class එකකට direct access කරන්න බැහැ. ඒත් Parent class එකේ Public methods හරහා ඒවාට access කරන්න පුළුවන්.
• final classes inherit කරන්න බැහැ: Class එකක් final කියලා declare කරලා තියෙනවා නම්, ඒකෙන් inherit කරන්න බැහැ.
• Method Signature: Overriding කරනකොට method signature (method name, return type, number and type of parameters) Parent method එකට සමාන විය යුතුයි.

අවසාන වශයෙන්

ඉතින් යාළුවනේ, Java වල Inheritance කියන්නේ Object-Oriented Programming වල හරිම බලගතු concept එකක්. මේකෙන් අපිට පුළුවන් code එක නැවත පාවිච්චි කරන්න (reusability), maintain කරන්න ලේසි කරන්න, ඒ වගේම extend කරන්න පුළුවන් විදිහට අපේ applications හදන්න. මම හිතනවා මේ ලිපියෙන් ඔයාලට Inheritance ගැන හොඳ අවබෝධයක් ලැබෙන්න ඇති කියලා.

දැන් ඉතින් ඔයාලගේ වාරේ! මේ concepts ඔයාලගේම IDE එකේ Try කරලා බලන්න. පොඩි පොඩි projects වලට මේක incorporate කරලා බලන්න. මොකද හිතෙන්නේ? මේ ලිපිය ගැන ඔයාලගේ අදහස් පහළින් comment කරන්න. ඒ වගේම තවත් මොන වගේ topics ගැනද දැනගන්න කැමති කියලාත් අපිට කියන්න. අපි ඊළඟ ලිපියෙන් හම්බවෙමු! සුබ දවසක්!