Python Tutorial - Learn Programming

Inheritance ဆိုတာ?

ဥပမာပေးရမယ်ဆို တကယ့် လက်တွေ့ဘဝနဲ့ တူတူပဲ။ ဘရို့အဖေ (Parent) မှာ ရှိတဲ့ အိမ်တွေ၊ ကားတွေ၊ ပိုင်ဆိုင်မှု (Attributes) တွေနဲ့ သူလုပ်တတ်တဲ့ အလုပ် (Methods) တွေကို သူ့သားသမီး (Child) ဖြစ်တဲ့ ဘရိုက အလိုလို အမွေရသွားတာ။

OOP မှာလည်း အဲ့ဒီအတိုင်းပဲ။

Class တစ်ခု ရှိတယ် ဆိုပါစို့။ အဲ့ဒီ class မှာ ရေးထားတဲ့ code တွေ (သူပိုင်တဲ့ data တွေ၊ သူလုပ်နိုင်တဲ့ skill တွေ) ကို နောက်ထပ် class အသစ်တစ်ခုက အမွေ ဆက်ခံပြီး အကုန်လုံးကို အလကား ရသွားတာမျိုးကို Inheritance လို့ခေါ်တယ်။

ဒါကို ဘာလို့ သုံးရတာလဲ?

အဓိကက Code ကို ပြန်သုံးချင်လို့ (Code Reusability)။

တစ်ခါ ရေးပြီးသား code ကို နောက်တစ်ခါ ထပ်မရေးတော့ဘူး။ Copy-paste တွေ လျှောက်လုပ်မနေတော့ဘူး။ DRY (Don't Repeat Yourself) ပေါ့ကွာ။ အဖေဆီမှာ ရှိပြီးသား skill ကို သားက ပြန်မကျင့်တော့ဘူး။ အမွေ ယူလိုက်ရုံပဲ။

အဓိက Players နှစ်ယောက်

Inheritance မှာ Player နှစ်ယောက်ရှိတယ်။

Parent Class (Superclass လို့လည်းခေါ်):

ဒါက အဖေ class။ မူရင်း class ကြီးပေါ့။

သူက သူ့ရဲ့ skill တွေ၊ property တွေကို အမွေပေးမယ့် လူ။

Child Class (ဒါမှမဟုတ် Subclass):

ဒါက သားသမီး class။ အသစ် ဆောက်လိုက်တဲ့ class။

သူက အဖေ class ဆီက အကုန် အမွေရမယ့် လူ။

ကဲ... Code နဲ့ ကြည့်မယ်

Scenario: လူ (Person) ဆိုတဲ့ class တစ်ခု ဆောက်မယ်။ ကျောင်းသား (Student) ဆိုတာ လူ (Person) တစ်မျိုးပဲ မလား။

ဒါ့ကြောင့် ကျောင်းသား (Student) class ကို လူ (Person) class ဆီက အမွေ ယူခိုင်းမယ်။

1. အဖေ Class (Parent) ကို အရင်ဆောက်မယ်

Person (လူ) တစ်ယောက်က ဘာလုပ်တတ်လဲ? စားမယ်၊ အိပ်မယ်။

                Parent Class Example
            
# ဒါက Parent Class (အဖေ)
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print(f"{self.name} ကို မွေးဖွားလိုက်ပြီ။")

    def eat(self):
        print(f"{self.name} က ထမင်းစားနေပြီ... ဗိုက်ဆာလို့။")

    def sleep(self):
        print(f"{self.name} အိပ်နေပြီ... မနှိုးနဲ့။")

# အဖေ class ကို စမ်းသုံးကြည့်မယ်
p1 = Person("ဦးဘ", 40)
p1.eat()  # ဦးဘ က ထမင်းစားနေပြီ... ဗိုက်ဆာလို့။

အိုခေ... Person class က အလုပ်လုပ်တယ်။

2. သား Class (Child) ဆောက်ပြီး အမွေယူမယ်

ကဲ... Student (ကျောင်းသား) class ဆောက်မယ်။ Student က Person ဆီက အမွေယူမှာမို့ class Student(Person): ဆိုပြီး ကွင်းစကွင်းပိတ် () ထဲမှာ အဖေ class နာမည်ကို ထည့်ရေးရတယ်။

                Child Class Example
            
# ဒါက Child Class (သား)
# Person ဆီက အမွေယူမယ်ဆိုတာ (Person) လို့ ထည့်ရေးရတယ်
class Student(Person):
    # Student က အပို skill တစ်ခု တတ်မယ်... စာကျက်တာပေါ့
    def study(self):
        print(f"{self.name} က စာကျက်နေတယ်... မိုက်တယ်ဟေ့။")

# ကဲ... အခု သား class ကို စမ်းသုံးကြည့်မယ်
s1 = Student("မောင်မောင်", 18)  # Person ရဲ့ __init__ ကို အလိုလို ခေါ်သွားတာ

# --- အမွေရထားတဲ့ Skill တွေ ---
s1.eat()
s1.sleep()

# --- သူ့ရဲ့ ကိုယ်ပိုင် Skill ---
s1.study()

Output က ဘာထွက်မလဲ ကြည့်:

                Output
            
မောင်မောင် ကို မွေးဖွားလိုက်ပြီ။
မောင်မောင် က ထမင်းစားနေပြီ... ဗိုက်ဆာလို့။
မောင်မောင် အိပ်နေပြီ... မနှိုးနဲ့။
မောင်မောင် က စာကျက်နေတယ်... မိုက်တယ်ဟေ့။

တွေ့လား ဘရို! Student class ထဲမှာ eat() တို့ sleep() တို့ __init__ တို့ တစ်လုံးမှ ပြန်မရေးရဘူး။ Person (အဖေ) ဆီက အမွေရလိုက်တာနဲ့ အဲ့ဒီ skill တွေက Student (သား) ဆီမှာ အလိုလို ပါလာပြီးသား ဖြစ်သွားတယ်။ study() ဆိုတဲ့ သူ့ skill အသစ်ကိုပဲ ထပ်ထည့်လိုက်ရုံပဲ။

နောက်တစ်ဆင့်: အဖေ့ဆီက ရတဲ့ Skill ကိုပြင်မယ်

နောက်တစ်ကွက်။

အဖေ (Person) က sleep() (အိပ်) တယ်။ သား (Student) ကလည်း sleep() (အိပ်) တယ်။ ဒါပေမယ့် သားက အဖေ အိပ်သလို မဟုတ်ဘူး။ သူက ဟောက်ပြီး အိပ်ချင်တယ်။

အဲ့လို အဖေ ဆီက အမွေရတဲ့ skill ကို သားက မကြိုက်လို့ သူ့ပုံစံနဲ့သူ ကျော်ပြီး ပြန်ရေးတာကို Method Overriding လို့ခေါ်တယ်။

လုပ်ရတာ လွယ်တယ်။ အဖေ ဆီက skill နာမည် (sleep) ကို သား class ထဲမှာ နာမည်အတိုင်း ပြန်ရေးလိုက်ရုံပဲ။

                Method Overriding Example
            
class Student(Person):
    # အဖေ့ဆီက sleep() ကို ယူမသုံးတော့ဘူး။
    # ကိုယ့်ဘာသာ အသစ် ရေးမယ် (Overriding)
    def sleep(self):
        print(f"{self.name} က ဟောက်ပြီး အိပ်နေပြီ... zZzZz")

    def study(self):
        print(f"{self.name} က စာကျက်နေတယ်... မိုက်တယ်ဟေ့။")

# စမ်းကြည့်မယ်
s2 = Student("အောင်အောင်", 20)
s2.eat()    # ဒါက အဖေ့ skill (မပြင်ထားဘူး)
s2.sleep()  # ဒါက သား ရေးလိုက်တဲ့ skill

Output:

                Output
            
အောင်အောင် ကို မွေးဖွားလိုက်ပြီ။
အောင်အောင် က ထမင်းစားနေပြီ... ဗိုက်ဆာလို့။
အောင်အောင် က ဟောက်ပြီး အိပ်နေပြီ... zZzZz  <-- တွေ့လား ဟောက်တဲ့ဟာ ဖြစ်သွားပြီ

နောက်ဆုံးတစ်ကွက်: super() ဆိုတဲ့ Magic Word

အိုခေ... ခုနက Student ဆောက်တုန်းက name နဲ့ age ပဲ ထည့်လို့ရတယ်။ Student မှာ student_id (ကျောင်းသားနံပါတ်) ပါ ထပ်ထည့်ချင်ရင်ကော?

သား (Student) က သူ့ __init__ ကို အသစ်ရေးရမယ်။ ဒါပေမယ့် အဖေ (Person) ရဲ့ __init__ ထဲမှာ name နဲ့ age ကို set လုပ်တဲ့ code တွေက ရှိပြီးသား။ အဲ့ဒါကို ပြန်မရေးချင်ဘူး။

အဲ့ဒီအခါ အဖေ့ရဲ့ skill ကို ခဏ ခေါ်သုံးမယ် လို့ ပြောဖို့ super() ကို သုံးတယ်။ super() ဆိုတာ ငါ့အဖေ (Parent) လို့ ပြောတာ။

                Using super()
            
class Student(Person):
    def __init__(self, name, age, student_id):
        # 1. အဖေ့ရဲ့ __init__ ကို အရင်ခေါ်ခိုင်းမယ်
        # (name နဲ့ age ကို သတ်မှတ်ဖို့)
        super().__init__(name, age)

        # 2. ပြီးမှ ကိုယ့်ဟာကိုယ် ထပ်ထည့်
        self.student_id = student_id
        print(f"ID {self.student_id} ပါ assign လုပ်ပြီး။")

    def study(self):
        print(f"{self.name} (ID: {self.student_id}) က စာကျက်နေပြီ။")

# ကဲ... အခု ၃ ခု နဲ့ ဆောက်ကြည့်မယ်
s3 = Student("ကျော်ကျော်", 19, "ID-1001")
s3.eat()
s3.study()

Output:

                Output
            
ကျော်ကျော် ကို မွေးဖွားလိုက်ပြီ။       <-- ဒါက super().__init__ ကနေ လာတာ
ID ID-1001 ပါ assign လုပ်ပြီး။    <-- ဒါက Student ရဲ့ __init__ က
ကျော်ကျော် က ထမင်းစားနေပြီ... ဗိုက်ဆာလို့။
ကျော်ကျော် (ID: ID-1001) က စာကျက်နေပြီ။

Boom! အခုဆို s3 မှာ အဖေ ဆီက name နဲ့ age ရော၊ သား ကိုယ်တိုင် ထပ်ထည့်လိုက်တဲ့ student_id ရော အကုန်ရှိသွားပြီ။

အနှစ်ချုပ်

Inheritance ဆိုတာ: အဖေ Class ဆီက skill တွေ၊ data တွေ အကုန်လုံးကို သား Class က အမွေရသွားတာ။
ဘာလို့သုံးလဲ?: Code တွေ ထပ်မရေးရတော့ဘူး (DRY)။
ဘယ်လိုရေးလဲ?: class Child(Parent): ဆိုပြီး ကွင်းစကွင်းပိတ်နဲ့ ရေးတယ်။
Overriding ဆိုတာ: အဖေ skill ကို မကြိုက်လို့ သား က သူ့ပုံစံနဲ့သူ ပြန်ရေးတာ။
super() ဆိုတာ: သား က အဖေ ရဲ့ method (အထူးသဖြင့် __init__) ကို ပြန်ခေါ်သုံးချင်တဲ့အခါ သုံးတယ်။