නූතන මෘදුකාංග ලෝකය පාලනය කරන, කේතකරණයේ විප්ලවීය වෙනසක් කළ ක්රමලේඛන චින්තන රටාව (Paradigm) පිළිබඳ ගැඹුරුම විග්රහය.
අපි මීට පෙර ලිපි මාලාවෙන් Variables, Loops, Functions සහ Databases වැනි programming වල මූලිකාංග ගැන ඉගෙන ගත්තා. ඒවායින් අපිට සරල වැඩසටහන් නිර්මාණය කරන්න පුළුවන්. නමුත්, ඔබ ෆේස්බුක් වැනි සමාජ ජාලයක්, Photoshop වැනි සංකීර්ණ මෘදුකාංගයක්, හෝ ඔබ සෙල්ලම් කරන video game එකක් ගැන සිතුවොත්, ඒ වගේ දැවැන්ත පද්ධති නිර්මාණය කරන්නේ කොහොමද? ඒ සඳහා සරල උපදෙස් මාලාවක් (a list of instructions) ලිවීම ප්රමාණවත්ද?
පිළිතුර 'නැහැ'. ඒ සඳහා අපිට වඩාත් සංවිධානාත්මක, බලවත් චින්තන රටාවක් අවශ්ය වෙනවා. අන්න ඒ චින්තන රටාවට තමයි **Object-Oriented Programming (OOP)** හෙවත් **වස්තු-කේන්ද්රීය ක්රමලේඛනය** කියලා කියන්නේ.
OOP කියන්නේ programming language එකක් නෙවෙයි. එය **ක්රමලේඛන සුසමාදර්ශයක් (Programming Paradigm)**, එනම්, වැඩසටහන් නිර්මාණය කිරීම සහ ව්යුහගත කිරීම පිළිබඳව සිතන ආකාරයක්. සරලවම කිව්වොත්, program එක උපදෙස් මාලාවක් ලෙස දකිනවා වෙනුවට, එකිනෙකා සමඟ ගනුදෙනු කරන **"වස්තූන්" (Objects)** එකතුවක් ලෙස දකින එක තමයි OOP වලින් වෙන්නේ.
OOP තේරුම් ගැනීමට පෙර, ඊට පෙර පැවති ප්රධාන ක්රමය වන **Procedural Programming** ගැන කෙටියෙන් දැන සිටීම වැදගත්. C, Pascal, FORTRAN වැනි භාෂා මේ ක්රමයට අයත්.
OOP ලෝකයේ සෑම දෙයක්ම පාහේ ගොඩනැගී ඇත්තේ මේ සංකල්ප දෙක මතයි.
අප අවට ලෝකය දෙස බලන්න. ඒක පිරිලා තියෙන්නේ වස්තූන්ගෙන්: මනුෂ්යයෙක්, බල්ලෙක්, පෑනක්, මෝටර් රථයක්. මේ සෑම වස්තුවකටම ප්රධාන ලක්ෂණ දෙකක් තියෙනවා:
Programming වලදී Object එකක් කියන්නෙත් මේකෙම ඩිජිටල් ආකෘතියක්. **Object එකක් යනු, ඊට අදාළ දත්ත (Attributes) සහ එම දත්ත මත ක්රියාත්මක වන ශ්රිත (Methods) එකට එකතු කර සෑදූ මෘදුකාංග ඒකකයකි.**
Object එකක් යනු සැබෑවටම පවතින දෙයක් නම්, Class එකක් යනු එම Object එක නිර්මාණය කිරීමට භාවිතා කරන **සැලැස්ම (Blueprint)** හෝ **අච්චුව (Template)** වේ.
මෝටර් රථ කර්මාන්ත ශාලාවක් ගැන සිතන්න. ඔවුන් එකම මාදිලියේ මෝටර් රථ දහස් ගණනක් නිෂ්පාදනය කරනවා. මේ සෑම මෝටර් රථයක්ම (Objects) වෙනස් වෙන්න පුළුවන් (එකක් රතු, එකක් නිල්). නමුත් ඒ සියල්ලම නිර්මාණය කරන්නේ එකම ඉංජිනේරු සැලැස්ම (Blueprint) භාවිතා කරලයි. අන්න ඒ සැලැස්ම තමයි **Class** එක.
Java, C++, C#, Python වැනි බොහෝ නූතන භාෂා OOP සඳහා සහාය දක්වයි. අපි Python භාවිතා කර `Car` class එකක් සහ objects කිහිපයක් හදමු.
# 1. පන්තිය නිර්වචනය කිරීම (Creating the Blueprint)
class Car:
# Constructor Method: Object එකක් හදනකොට මුලින්ම ක්රියාත්මක වෙන method එක
def __init__(self, brand, model, color):
# Attributes (ගුණාංග)
self.brand = brand
self.model = model
self.color = color
self.is_engine_on = False
# Methods (ක්රියාකාරීත්වය)
def start_engine(self):
self.is_engine_on = True
print(f"The {self.brand} {self.model}'s engine is now on. Vroom!")
def stop_engine(self):
self.is_engine_on = False
print(f"The {self.brand} {self.model}'s engine is now off.")
# 2. පන්තියෙන් වස්තූන් නිර්මාණය කිරීම (Creating actual cars from the blueprint)
my_car = Car("Toyota", "Corolla", "Red")
your_car = Car("Honda", "Civic", "Blue")
# 3. වස්තූන්ගේ attributes සහ methods භාවිතා කිරීම
print(f"My car is a {my_car.color} {my_car.brand}.") # Accessing attributes
print(f"Your car is a {your_car.color} {your_car.brand}.")
my_car.start_engine() # Calling a method
your_car.start_engine()
your_car.stop_engine()
මෙහි `Car` යනු Class එකයි. `my_car` සහ `your_car` යනු එම Class එකෙන් සෑදූ Objects (instances) දෙකකි.
OOP හි බලය සහ අලංකාරය රැඳී පවතින්නේ එහි මූලික මූලධර්ම හෙවත් කුළුණු හතර මතයි. මේවා තේරුම් ගැනීම OOP ප්රගුණ කිරීමට අත්යවශ්ය වේ.
Encapsulation යනු **දත්ත (attributes) සහ එම දත්ත මත ක්රියාත්මක වන methods, එකට එකතු කර, තනි ඒකකයක් (Class/Object) ලෙස "ඇසිරීමයි".** මෙය හරියට බෙහෙත් කරලක් (capsule) වගෙයි. කරලේ ප්ලාස්ටික් ආවරණය, ඇතුළේ ඇති බෙහෙත් කුඩු ටික බාහිර ලෝකයෙන් ආරක්ෂා කර තබා ගනී.
මෙහි ප්රධාන අරමුණ වන්නේ **දත්ත සැඟවීම (Data Hiding)** යි. එනම්, object එකක ඇති දත්ත වලට පිටතින් කෙලින්ම, පාලනයකින් තොරව ප්රවේශ වීම සහ වෙනස් කිරීම වැළැක්වීමයි. ඔබට එම දත්ත සමඟ ගනුදෙනු කිරීමට අවශ්ය නම්, ඔබ ඒ සඳහා object එක විසින්ම සපයා ඇති public methods භාවිතා කළ යුතුය. අපේ `Car` උදාහරණයේ, `is_engine_on` attribute එක කෙලින්ම වෙනස් කරනවා වෙනුවට, `start_engine()` සහ `stop_engine()` methods භාවිතා කිරීම හොඳ පුරුද්දකි.
Abstraction යනු **සංකීර්ණ ක්රියාකාරීත්වය සඟවා, පරිශීලකයාට අවශ්ය අත්යවශ්ය තොරතුරු පමණක් පෙන්වීමයි.** ඔබ මෝටර් රථයක් පදවන විට, ඔබ භාවිතා කරන්නේ සුක්කානම, ඇක්සලරේටරය, සහ තිරිංග පමණි. එන්ජිම ඇතුළේ ඉන්ධන දැවෙන ආකාරය, ගියර් මාරු වන ආකාරය වැනි සංකීර්ණ දේවල් ඔබ දැනගත යුතු නැත. මෝටර් රථය එම සංකීර්ණත්වය ඔබෙන් "සඟවා" (abstracted away) ඇත.
Programming වලදී, Abstraction මගින් අපි පරිශීලකයාට සරල interface එකක් (public methods) ලබා දෙන අතර, එම methods ඇතුළේ සිදුවන සංකීර්ණ ක්රියාවලිය සඟවා තබමු. `my_car.start_engine()` කියා call කළ විට, එය ඇතුළේ spark plug, fuel injection වැනි ක්රියාවලි සිය ගණනක් සිදු විය හැකි නමුත්, අපිට පෙනෙන්නේ සරල method call එක පමණි.
Inheritance යනු **එක් class එකක් (Child Class / Subclass) විසින් තවත් class එකක (Parent Class / Superclass) attributes සහ methods උරුම කර ගැනීමේ හැකියාවයි.** මෙය හරියට දරුවන් දෙමව්පියන්ගෙන් ගති ලක්ෂණ උරුම කර ගන්නවා වගෙයි. මෙමගින් කේතය නැවත නැවත ලිවීම (code duplication) වලක්වා ගත හැක.
Inheritance මගින් **"IS-A"** සම්බන්ධතාවයක් නිරූපණය කරයි. උදාහරණයක් ලෙස:
අපි මුලින්ම පොදු `Vehicle` class එකක් හදමු. ඉන්පසු, එයින් `Car` සහ `Motorcycle` යන class දෙක උරුම කරවමු.
# Parent Class (Superclass)
class Vehicle:
def __init__(self, brand):
self.brand = brand
print("Vehicle object created.")
def move(self):
print("Moving forward...")
# Child Class (Subclass) that inherits from Vehicle
class Car(Vehicle):
def __init__(self, brand, doors):
super().__init__(brand) # Call parent's constructor
self.doors = doors
print("Car object created.")
def honk(self):
print("Beep beep!")
# Another Child Class
class Motorcycle(Vehicle):
def wheelie(self):
print("Doing a cool wheelie!")
my_new_car = Car("Nissan", 4)
my_motorcycle = Motorcycle("Yamaha")
my_new_car.move() # 'move' method is inherited from Vehicle
my_new_car.honk() # 'honk' is its own method
my_motorcycle.move() # Inherited method
my_motorcycle.wheelie() # Own method
මෙහි `Car` සහ `Motorcycle` යන class දෙකටම `Vehicle` class එකේ ඇති `move()` method එක උරුම වී ඇත, එබැවින් එය නැවත ලිවීමට අවශ්ය නැත.
Polymorphism යනු ග්රීක වචනයක් වන අතර, එහි තේරුම **"බොහෝ ආකාර (many forms)"** යන්නයි. OOP වලදී, polymorphism යනු **විවිධ classes වලට අයත් objects, එකම නම ඇති method එකකට, තමන්ටම ආවේණික ආකාරයට ප්රතිචාර දැක්වීමේ හැකියාවයි.**
සරලම උදාහරණය නම් "+" ලකුණයි. සංඛ්යා (`int`) දෙකක් අතර යෙදූ විට එය **එකතු කිරීමක්** (`5 + 3 = 8`) සිදු කරයි. නමුත් string දෙකක් අතර යෙදූ විට එය **සම්බන්ධ කිරීමක්** (`"hello" + "world" = "helloworld"`) සිදු කරයි. එකම ක්රියාකරු (`+`) විවිධ දත්ත වර්ග මත විවිධ ආකාරයට හැසිරේ.
Inheritance සමඟ මෙය ඉතා බලවත් වේ. Parent class එකේ ඇති method එකක්, child class එකේදී වෙනස් ආකාරයකට ක්රියාත්මක වන ලෙස නැවත ලිවිය හැක. ഇതിന് **Method Overriding** എന്ന് പറയുന്നു.
class Animal:
def speak(self):
print("Some generic animal sound")
class Dog(Animal):
# Overriding the parent's speak method
def speak(self):
print("Woof woof!")
class Cat(Animal):
# Overriding the parent's speak method
def speak(self):
print("Meow!")
# Create a list of different animal objects
animals = [Dog(), Cat(), Animal()]
# Call the same method on different objects
for animal in animals:
animal.speak()
ප්රතිදානය (Output):
Woof woof!
Meow!
Some generic animal sound
මෙම උදාහරණයේ, අපි `animal.speak()` යන එකම method call එක භාවිතා කළත්, `Dog` object එක වෙනස් විදිහකටත්, `Cat` object එක වෙනස් විදිහකටත් ප්රතිචාර දක්වයි. මේක තමයි Polymorphism.
Object-Oriented Programming යනු හුදෙක් කේත ලියන ක්රමයක් පමණක් නොවේ; එය සංකීර්ණ ගැටළු විසඳීම සඳහා වූ බලවත් චින්තන මෙවලමකි. එය අපට සැබෑ ලෝකය, මෘදුකාංගයක් තුළ වඩාත් තාත්විකව නිරූපණය කිරීමට ඉඩ සලසයි.
අපි ඉගෙන ගත් ප්රධාන කරුණු:
ඔබ Java, C#, Python, C++ වැනි භාෂාවක් ඉගෙන ගනිමින් සිටින්නේ නම්, OOP මූලධර්ම පිළිබඳව මනා අවබෝධයක් ලබා ගැනීම, ඔබව සාමාන්ය කේත රචකයෙකුගේ සිට දක්ෂ මෘදුකාංග නිර්මාණ ශිල්පියෙකු දක්වා ඔසවා තබනු ඇත. මෙම සංකල්ප භාවිතා කර කුඩා ව්යාපෘති නිර්මාණය කරමින් පුහුණු වීම, මේවා ප්රගුණ කිරීමට ඇති හොඳම මාර්ගයයි.
ඊළඟට කුමක්ද? ඔබ දැන් programming වල මූලික සහ උසස් සංකල්ප රැසක් දන්නවා. O/L සහ A/L විභාග සඳහා මෙම දැනුම ඉතා වැදගත්. අපගේ ඊළඟ ලිපි මාලාවෙන්, අපි **O/L ICT විභාග සටහන්** පිළිබඳව අවධානය යොමු කරමු!