目次
1. Pangkalahatang-ideya ng Pagmamana sa Python
Sa Python, ang pagmamana ay isang mekanismo kung saan ang mga anak na klase ay nagmamana ng mga tampok at katangian mula sa magulang na klase. Dahil dito, tumataas ang muling paggamit ng code at napapabuti ang kahusayan ng pagpapanatili. Isa ito sa mga mahalagang konsepto ng Object-Oriented Programming (OOP) at kapaki-pakinabang lalo na sa malakihang pagbuo ng sistema at mga pangmatagalang proyekto.Pangunahing Gampanin ng Pagmamana
- Reusability ng code: Dahil maaaring magamit ang mga tampok ng isang klase sa iba pang mga klase, maiiwasan ang pag-uulit ng code.
- Kadalian ng maintenance: Dahil awtomatikong nasasalamin ang mga pagbabago sa magulang na klase papunta sa mga anak na klase, mas epektibo ang pag-aayos at pagpapalawak ng mga tampok.
class ParentClass:
def greet(self):
print("Kamusta, ito ay parent class.")
class ChildClass(ParentClass):
def greet(self):
print("Kamusta, ito ay child class.")ChildClass ay nag-ooverride ng method ng ParentClass. Dahil na-override ang method na greet, nagpapakita ang child class ng sarili nitong pagbati.2. Isang Pamana sa Python
Isang Pamana ay isang anyo kung saan isang parent class ay nagmamana ng mga katangian sa isang child class. Ito ang pangunahing anyo ng pamana sa Python, na nagbibigay-daan upang mapanatili ang pagiging simple ng code habang pinapahintulutan ang pagpapalawak.Pangunahing Sintaks at Halimbawa ng Isang Pamana
class Car:
def __init__(self, brand, color):
self.brand = brand
self.color = color
def describe(self):
print(f"Ang sasakyan na ito ay kulay {self.color} na {self.brand}.")
class ElectricCar(Car):
def __init__(self, brand, color, battery_size):
super().__init__(brand, color)
self.battery_size = battery_size
def describe_battery(self):
print(f"Ang kapasidad ng baterya ay {self.battery_size}kWh.")ElectricCar ay nagmamana ng mga katangian mula sa klase na Car habang nagdadagdag ng kakayahang magpaliwanag ng kapasidad ng baterya. Ginagamit ang super() upang tawagin ang constructor ng parent class at i-initialize ang mga karaniwang katangian (brand at kulay).
3. Pag-override ng Metodo
Pag-override ay isang tampok kung saan muling tinutukoy ng subclass ang method ng parent class. Sa pamamagitan nito, maaaring gamitin ang method ng parent class habang binabago ang pag-uugali sa subclass.Halimbawa ng Pag-override
class Animal:
def speak(self):
print("Tunog ng hayop")
class Dog(Animal):
def speak(self):
print("Aw aw!")Dog ay nag-o-override ng method na speak ng klase Animal. Dahil dito, ang mga instance ng klase Dog ay maglalabas ng “Aw aw”, samantalang ang mga instance ng klase Animal ay magpapakita ng “Tunog ng hayop”.4. Multiple Inheritance
Sa multiple inheritance, isang child class ay maaaring magmana mula sa maraming parent class. Dahil dito, maaaring pagsamahin ang mga tampok ng iba’t ibang klase sa isang klase, ngunit kailangan mag-ingat dahil maaaring maging kumplikado ang implementasyon.Halimbawa at mga Paalala sa Multiple Inheritance
class A:
def greet(self):
print("Bating mula kay A")
class B:
def greet(self):
print("Bating mula kay B")
class C(A, B):
pass
c = C()
c.greet() # Ipinapakita ang "Bating mula kay A" (ang unang klase ay may prayoridad alinsunod sa MRO)C.mro(). Ang multiple inheritance ay makapangyarihan, ngunit kailangan itong gamitin nang may pag-iisip sa mga posibleng banggaan ng mga parent class at sa pagkakasunud-sunod ng mga method.
5. Mga Praktikal na Halimbawa ng Paggamit ng Pagmamana
Ang pagmamana ay maraming pagkakataon na kapaki-pakinabang kahit sa pang-araw-araw na pagprograma. Halimbawa, sa isang sistema ng pamamahala ng mga empleyado ng kumpanya, maaaring magmana mula sa pangunahing klase ng empleyado patungo sa mga klase na may tiyak na posisyon, na nagpapahintulot sa muling paggamit at pagpapalawak ng code.Halimbawa ng Praktikal na Sistema ng Pamamahala ng Empleyado
class Employee:
def __init__(self, first, last, pay):
self.first = first
self.last = last
self.pay = pay
def fullname(self):
return f'{self.first} {self.last}'
class Manager(Employee):
def __init__(self, first, last, pay, employees=None):
super().__init__(first, last, pay)
self.employees = employees if employees is not None else []
def add_employee(self, employee):
if employee not in self.employees:
self.employees.append(employee)
def print_employees(self):
for emp in self.employees:
print(emp.fullname())Manager ay nagmamana mula sa klase na Employee, at nagdadagdag ng mga tampok sa pamamahala ng mga empleyado. Pinananatili nito ang mga karaniwang tampok ng magulang na klase habang pinalalawak ang mga tampok ayon sa tiyak na posisyon.6. Pinakamahusay na Kasanayan sa Pagmamana at Paghahambing sa Komposisyon
Ang pagmamana ay napakalakas, ngunit kung labis na gagamitin, may panganib na maging komplikado ang code. Lalo na, ang multiple inheritance ay maaaring magpalala ng relasyon sa pagitan ng mga klase, kaya dapat itong gamitin nang maingat. Sa ganitong mga kaso, inirerekomenda na gamitin ang komposisyon sa halip na pagmamana.Halimbawa ng Komposisyon
Ang komposisyon ay isang disenyo kung saan ang isang klase ay nagtataglay ng ibang klase bilang bahagi (instansya) upang i-delegate ang mga functionality.class Engine:
def start(self):
print("Nagsimula na ang makina.")
class Car:
def __init__(self, engine):
self.engine = engine
def start(self):
self.engine.start()
engine = Engine()
car = Car(engine)
car.start() # Ipinapakita ang "Nagsimula na ang makina."
7. Buod
Ang inheritance sa Python ay isang makapangyarihang tool para mapabuti ang muling paggamit ng code at ang kakayahang palawakin ito. Sa pamamagitan ng pag-unawa sa mga teknik tulad ng single inheritance, multiple inheritance, at overriding, makakalikha ka ng mga programang epektibo at madaling mapanatili. Samantala, mahalagang isaalang-alang ang tamang paghahati sa pagitan ng composition at inheritance, at magdisenyo nang naaayon. Sa pamamagitan ng mahusay na paggamit ng tamang inheritance, makakabuo ka ng isang flexible at matibay na code base.