හලෝ යාළුවනේ, කොහොමද?

අද අපි කතා කරන්න යන්නේ Object-Oriented Programming (OOP) වල තියෙන සුපිරි සංකල්පයක් ගැන – ඒ තමයි Abstraction. මේක හරියට පොඩි මැජික් එකක් වගේ, වැඩ කරන විදිය හංගලා අපිට ඕන දේ විතරක් පෙන්නනවා. අපි දන්නවනේ Software Development කියන්නේ හැමදාම අලුත් දේවල් ඉගෙන ගන්න තියෙන ක්ෂේත්‍රයක් කියලා. ඒ වගේම, අපි ලියන code එක maintain කරන්න, extend කරන්න, සහ තවත් අය එක්ක එකතු වෙලා වැඩ කරන්න පුළුවන් විදියට හදාගන්න එක හරිම වැදගත්. Abstraction කියන සංකල්පය මේකට අපිට ලොකු සහයෝගයක් දෙනවා.

Abstraction කියන්නේ මොකක්ද? (What is Abstraction?)

නම ඇහුවම චුට්ටක් බය හිතෙන්න පුලුවන්, හැබැයි මේක හරිම සරලයි. Abstraction කියන්නේ අපිට මොකක් හරි දෙයක් වැඩ කරන විදිය හෝ ඒකේ ඇතුලේ තියෙන සංකීර්ණ දේවල් හංගලා, ඒකෙන් අපිට ලැබෙන සේවාව විතරක් පෙන්නන එක. මේකේ ප්‍රධානම අරමුණ තමයි complexity එක අඩු කරන එක.

අපි daily life එකේදීත් නොදැනුවත්වම Abstraction පාවිච්චි කරනවා. උදාහරණයක් විදියට, ඔයා ෆෝන් එකකින් කෝල් එකක් ගන්නකොට, කෝල් එක connect වෙන්න ඇතුලේ වෙන දේවල් ගැන හිතනවද? නැහැනේ! ඔයාට ඕන කෝල් එක යන එක විතරයි. SIM එකක් signal tower එකට connect වෙන්නේ කොහොමද, data packets translate වෙන්නේ කොහොමද, මේ කිසිදෙයක් ඔයාට වැදගත් නෑ. ඔයාට වැදගත් වෙන්නේ කෝල් එක යන එක විතරයි.

ඒ වගේම, ඔයා ATM එකකින් සල්ලි ගන්න යනකොට, ඔයාට ඕන වෙන්නේ button ටිකක් ඔබලා සල්ලි ගන්න විතරයි. ATM එක ඇතුලේ සල්ලි ගනන් කරන mechanism එකක්, ඔයාගේ bank account එක එක්ක connect වෙන process එකක් ගැන ඔයාට දැනගන්න ඕන නෑ. මේක තමයි Abstraction. Software Development වලදීත් මේක හරියටම මෙහෙම තමයි ක්‍රියා කරන්නේ. අපි method එකක් call කරනකොට, ඒ method එක ඇතුලේ මොනවද වෙන්නේ කියලා අපි හැමවෙලේම දැනගන්න ඕන නෑ. අපිට ඕන ඒකෙන් ලැබෙන output එක විතරයි.

Python වල Abstract Base Classes (ABCs) (ABCs in Python)

Python වල මේ Abstraction කියන concept එක implement කරන්න අපිට Abstract Base Classes (ABCs) පාවිච්චි කරන්න පුළුවන්. මේකට abc කියලා built-in module එකක් තියෙනවා. මේකේ ABC කියන class එකයි @abstractmethod කියන decorator එකයි තමයි ප්‍රධානම දේවල්.

• Abstract class එකක් කියන්නේ මොකක්ද?: සරලවම කිව්වොත්, Abstract class එකක් කියන්නේ ඒකෙන් object හදන්න බැරි class එකක්. ඒක තියෙන්නේ වෙනත් classes වලට blueprint එකක් විදියට පාවිච්චි කරන්න. ඒ කියන්නේ, මේ abstract class එක inherit කරන child classes වලට අනිවාර්යයෙන්ම implement කරන්න ඕන methods මොනවද කියලා මේ class එකෙන් අපිට define කරන්න පුළුවන්.
• @abstractmethod decorator එක: මේ decorator එක පාවිච්චි කරන්නේ method එකක් abstract කියලා define කරන්න. abstract method එකක් කියන්නේ ඒකේ implementation එකක් නැති method එකක්. ඒකේ body එක හිස්ව තියෙන්න පුළුවන් (e.g., pass keyword එක දාලා).

Abstract class එකක abstract method එකක් තියෙනවා නම්, ඒ class එක inherit කරන හැම subclass එකක්ම අනිවාර්යයෙන්ම ඒ abstract method එක implement කරන්න ඕන. එහෙම නැත්නම් error එකක් එනවා. මේකෙන් අපිට පුළුවන් standard එකක් හදාගන්න. ඒ කියන්නේ, අපේ team එකේ හැම developer කෙනෙක්ම යම්කිසි feature එකක් implement කරනකොට, ඒකේ අනිවාර්යයෙන්ම තියෙන්න ඕන methods මොනවද කියලා මේ Abstraction හරහා enforce කරන්න පුළුවන්. මේකෙන් code consistency එක වැඩි වෙනවා වගේම, maintainability එකත් වැඩි වෙනවා.

ප්‍රායෝගික උදාහරණයක් (A Practical Example)

දැන් අපි Python වල මේ Abstraction ක්‍රියාවට නගන්නේ කොහොමද කියලා සරල උදාහරණයක් බලමු. අපි හිතමු, අපිට විවිධ වර්ගයේ හැඩතල (Shapes) වල වර්ගඵලය (area) ගණනය කරන්න system එකක් හදන්න ඕන කියලා. හැම හැඩතලයකටම area එකක් තියෙනවා, හැබැයි ඒක ගණනය කරන විදිය හැඩතලයෙන් හැඩතලයට වෙනස් වෙනවා (වෘත්තයකට, ත්‍රිකෝණයකට, සෘජුකෝණාස්‍රයකට වගේ). මෙතනදී Abstraction පාවිච්චි කරන්න පුළුවන්. අපි Shape කියලා Abstract Base Class එකක් හදමු, ඒකේ area() කියලා abstract method එකක් තියෙන්න ඕන කියලා කියමු. ඊට පස්සේ Circle සහ Rectangle වගේ concrete subclasses හැදුවට පස්සේ, ඒ හැම class එකක්ම අනිවාර්යයෙන්ම area() method එක implement කරන්න ඕන.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass # No implementation here, just a placeholder

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

# Using the classes
my_circle = Circle(5)
print(f"Circle Area: {my_circle.area()}")

my_rectangle = Rectangle(4, 6)
print(f"Rectangle Area: {my_rectangle.area()}")

# Try to instantiate Shape (will raise TypeError)
# my_shape = Shape()

ඔයාලට පේනවා ඇති, Shape class එකේ area method එකේ කිසිම implementation එකක් නැහැ. ඒක pass කියලා විතරක් තියෙන්නේ. ඒක abstractmethod එකක් නිසා. ඊට පස්සේ Circle සහ Rectangle කියන subclasses දෙක Shape එකෙන් inherit කරලා, ඒ දෙකම තමන්ගේම විදියට area method එක implement කරනවා. මේකෙන් වෙන්නේ, Shape එකෙන් inherit කරන ඕනෑම class එකක් area method එක අනිවාර්යයෙන්ම implement කරන්න ඕන කියන එක enforce වෙන එකයි. මේකෙන් අපිට බලාගන්න පුළුවන්, කොච්චර ලස්සනට Abstraction concept එක Python වල ABCs හරහා ක්‍රියාවට නගන්න පුළුවන්ද කියලා.

වැරදි සහ හොඳ පුරුදු (Errors and Best Practices)

අපි කලින් කතා කරපු විදියට, Abstract class එකකින් inherit කරන හැම subclass එකක්ම ඒ Abstract class එකේ තියෙන හැම abstract method එකක්ම implement කරන්න ඕන. එහෙම නොකළොත් මොකද වෙන්නේ? Python එකෙන් TypeError එකක් දානවා.

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def start(self):
        pass

    @abstractmethod
    def stop(self):
        pass

class Car(Vehicle):
    def start(self):
        print("Car started!")
    # stop() method is NOT implemented here!

# This will raise a TypeError:
# "Can't instantiate abstract class Car with abstract method stop"
# my_car = Car()

උඩ තියෙන උදාහරණය බලන්න. අපි Vehicle කියලා Abstract class එකක් හැදුවා, ඒකේ start() සහ stop() කියලා abstract methods දෙකක් තියෙනවා. ඊට පස්සේ Car කියලා subclass එකක් හැදුවා, ඒකේ start() method එක implement කරා, හැබැයි stop() method එක අමතක වෙලා. දැන් ඔයා Car class එකේ object එකක් හදන්න හැදුවොත්, Python එකෙන් කියනවා Car කියන්නේ abstract class එකක්, ඒකේ stop කියන abstract method එක implement කරලා නැහැ කියලා. මේකෙන් වෙන්නේ, අපි design කරපු interface එකෙන් පිට යන්න බැරි වෙන එක.

ABCs පාවිච්චි කරන්න ඕන කවද්ද? (When to use ABCs?):

• Interfaces enforce කරන්න: ඔයා system එකක design එකක් හදනකොට, යම්කිසි functionality එකක් හැම component එකකින්ම implement කරන්න ඕන නම්, මේක පාවිච්චි කරන්න පුළුවන්.
• Frameworks හදනකොට: වෙනත් developers ලා පාවිච්චි කරන libraries හදනකොට, නිශ්චිත ක්‍රමවේදයක් (pattern) අනුගමනය කරන්න මේක උදව් වෙනවා.
• Common functionality define කරන්න: යම්කිසි group එකක classes වලට පොදු functions set එකක් තියෙන්න ඕන නම්, ඒ functions abstract methods විදියට define කරලා enforce කරන්න පුළුවන්.
• Code clarity and maintainability: Code එක තේරුම් ගන්න ලේසියි, මොකද දන්නවා මේ class එකෙන් මේ methods ටික අනිවාර්යයෙන්ම expect කරනවා කියලා.

හැබැයි මතක තියාගන්න, හැමතැනම ABCs පාවිච්චි කරන්න ඕන නෑ. සරල class hierarchies වලට මේක අනවශ්‍ය විදියට complexity එක වැඩි කරන්න පුළුවන්. අවශ්‍ය තැනට විතරක් judiciously පාවිච්චි කරන එක තමයි හොඳම දේ.

අවසන් වචන

ඉතින්, Abstraction කියන්නේ OOP වල තියෙන හරිම වැදගත් concept එකක්. implementation details හංගලා, අපිට ඕන දේ විතරක් focus කරන්න මේක උදව් වෙනවා. Python වල Abstract Base Classes (ABCs) පාවිච්චි කරලා මේක අපිට ලේසියෙන්ම implement කරන්න පුළුවන්. මේකෙන් අපේ code එක organize කරන්න, consistency එක වැඩි කරන්න, සහ future extensions වලට සූදානම් කරන්න ලොකු සහයෝගයක් ලැබෙනවා.

අද අපි කතා කරපු දේවල් ඔයාලට වැදගත් වෙන්න ඇති කියලා හිතනවා. ખાસ કરીને software design, architecture ගැන උනන්දු අයට මේක තවත් ගොඩක් වැදගත් වෙයි. මේ ගැන ඔයාලට තවත් ප්‍රශ්න තියෙනවද? නැත්නම් මේක තවත් කොහොමද use කරන්න පුළුවන් කියලා අදහසක් තියෙනවද? පහලින් comment එකක් දාගෙන යන්න! ඔයාලත් මේ concept එක use කරලා පොඩි Python code කෑල්ලක් ලියලා බලන්න. එතකොට තවත් හොඳට තේරෙයි. ඊළඟ article එකෙන් හම්බවෙමු! තෙරුවන් සරණයි!