ಇನ್ಹೆರಿಟೆನ್ಸ್ (Inheritance)

ಇನ್ಹೆರಿಟೆನ್ಸ್ (Inheritance) ಎನ್ನುವುದು ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ (OOP) ಒಂದು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ. ಇದು ಒಂದು ಕ್ಲಾಸ್‌ಗೆ (ಇದನ್ನು "ಚೈಲ್ಡ್" ಅಥವಾ "ಸಬ್‌ಕ್ಲಾಸ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ) ಮತ್ತೊಂದು ಕ್ಲಾಸ್‌ನ (ಇದನ್ನು "ಪೇರೆಂಟ್" ಅಥವಾ "ಬೇಸ್ ಕ್ಲಾಸ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ) ಗುಣಲಕ್ಷಣಗಳನ್ನು (attributes) ಮತ್ತು ವಿಧಾನಗಳನ್ನು (methods) ಪಡೆದುಕೊಳ್ಳಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಇನ್ಹೆರಿಟೆನ್ಸ್‌ನ ಮುಖ್ಯ ಉದ್ದೇಶ ಕೋಡ್ ಅನ್ನು ಪುನಃ ಬಳಸುವುದು (code reusability). ಒಮ್ಮೆ ನೀವು ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಕೋಡ್ ಬರೆದರೆ, ಅದನ್ನು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ಗಳಲ್ಲಿ ಮತ್ತೆ ಬರೆಯುವ ಅಗತ್ಯವಿಲ್ಲ.

ಇನ್ಹೆರಿಟೆನ್ಸ್ ಅನ್ನು ಏಕೆ ಬಳಸಬೇಕು?

• ಕೋಡ್ ಪುನರ್ಬಳಕೆ: ಒಂದೇ ರೀತಿಯ ಕೋಡ್ ಅನ್ನು ಹಲವು ಕಡೆ ಬರೆಯುವುದನ್ನು ತಪ್ಪಿಸಬಹುದು.
• ಸಂಘಟನೆ: ಕ್ಲಾಸ್‌ಗಳನ್ನು ಒಂದು ಕ್ರಮಾನುಗತ ರಚನೆಯಲ್ಲಿ (hierarchical structure) ಸಂಘಟಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
• ನಿರ್ವಹಣೆ: ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸುವುದು ಸುಲಭವಾಗುತ್ತದೆ. ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಮಾಡಿದ ಬದಲಾವಣೆಗಳು ಎಲ್ಲಾ ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ಗಳಿಗೂ ಅನ್ವಯವಾಗುತ್ತವೆ.

ಇನ್ಹೆರಿಟೆನ್ಸ್ ವಿಧಗಳು

ಪೈಥಾನ್‌ನಲ್ಲಿ ಹಲವು ರೀತಿಯ ಇನ್ಹೆರಿಟೆನ್ಸ್ ಇವೆ:

1. ಏಕ ಇನ್ಹೆರಿಟೆನ್ಸ್ (Single Inheritance): ಒಂದು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್ ಕೇವಲ ಒಂದು ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನಿಂದ ಇನ್ಹೆರಿಟ್ ಆಗುತ್ತದೆ.
2. ಬಹು ಇನ್ಹೆರಿಟೆನ್ಸ್ (Multiple Inheritance): ಒಂದು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ಗಳಿಂದ ಇನ್ಹೆರಿಟ್ ಆಗುತ್ತದೆ.
3. ಮಲ್ಟಿಲೆವೆಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ (Multilevel Inheritance): ಒಂದು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್ ಮತ್ತೊಂದು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ನಿಂದ ಇನ್ಹೆರಿಟ್ ಆಗುತ್ತದೆ.
4. ಹೈರಾರ್ಕಿಕಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ (Hierarchical Inheritance): ಒಂದೇ ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನಿಂದ ಹಲವು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ಗಳು ಇನ್ಹೆರಿಟ್ ಆಗುತ್ತವೆ.
5. ಹೈಬ್ರಿಡ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ (Hybrid Inheritance): ಮೇಲಿನ ಎರಡು ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚು ಇನ್ಹೆರಿಟೆನ್ಸ್ ಪ್ರಕಾರಗಳ ಸಂಯೋಜನೆ.

---

1. ಏಕ ಇನ್ಹೆರಿಟೆನ್ಸ್ (Single Inheritance)

ಇದು ಅತ್ಯಂತ ಸರಳವಾದ ಇನ್ಹೆರಿಟೆನ್ಸ್ ಪ್ರಕಾರ.

ಉದಾಹರಣೆ:

# ಪೇರೆಂಟ್ ಕ್ಲಾಸ್
class Animal:
    def __init__(self, name):
        self.name = name
        print(f"{self.name} ಎಂಬ ಪ್ರಾಣಿ ಜನಿಸಿದೆ.")

    def eat(self):
        print(f"{self.name} ತಿನ್ನುತ್ತಿದೆ.")

# ಚೈಲ್ಡ್ ಕ್ಲಾಸ್
class Dog(Animal):
    def bark(self):
        print(f"{self.name} ಬೊಗಳುತ್ತಿದೆ.")

# ಆಬ್ಜೆಕ್ಟ್ ರಚಿಸುವುದು
my_dog = Dog("ರಾಮು")
my_dog.eat()   # ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನ ಮೆಥಡ್
my_dog.bark()  # ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ನ ಮೆಥಡ್

ಔಟ್‌ಪುಟ್:

ರಾಮು ಎಂಬ ಪ್ರಾಣಿ ಜನಿಸಿದೆ.
ರಾಮು ತಿನ್ನುತ್ತಿದೆ.
ರಾಮು ಬೊಗಳುತ್ತಿದೆ.

2. ಬಹು ಇನ್ಹೆರಿಟೆನ್ಸ್ (Multiple Inheritance)

ಒಂದು ಕ್ಲಾಸ್ ಹಲವು ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ಗಳಿಂದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪಡೆಯುತ್ತದೆ.

ಉದಾಹರಣೆ:

class Father:
    def __init__(self):
        print("ತಂದೆಯ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್")

    def skill_father(self):
        print("ತಂದೆಯಿಂದ ಬಂದ ಕೌಶಲ್ಯ: ವ್ಯವಸಾಯ")

class Mother:
    def __init__(self):
        print("ತಾಯಿಯ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್")

    def skill_mother(self):
        print("ತಾಯಿಯಿಂದ ಬಂದ ಕೌಶಲ್ಯ: ಅಡುಗೆ")

class Child(Father, Mother):
    def __init__(self):
        # ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ಗಳ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳನ್ನು ಕರೆಯುವುದು
        Father.__init__(self)
        Mother.__init__(self)
        print("ಮಗುವಿನ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್")

    def skill_child(self):
        print("ಮಗುವಿನ ಸ್ವಂತ ಕೌಶಲ್ಯ: ಕೋಡಿಂಗ್")

# ಆಬ್ಜೆಕ್ಟ್ ರಚಿಸುವುದು
ch = Child()
ch.skill_father()
ch.skill_mother()
ch.skill_child()

ಔಟ್‌ಪುಟ್:

ತಂದೆಯ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್
ತಾಯಿಯ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್
ಮಗುವಿನ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್
ತಂದೆಯಿಂದ ಬಂದ ಕೌಶಲ್ಯ: ವ್ಯವಸಾಯ
ತಾಯಿಯಿಂದ ಬಂದ ಕೌಶಲ್ಯ: ಅಡುಗೆ
ಮಗುವಿನ ಸ್ವಂತ ಕೌಶಲ್ಯ: ಕೋಡಿಂಗ್

ಗಮನಿಸಿ: ಬಹು ಇನ್ಹೆರಿಟೆನ್ಸ್‌ನಲ್ಲಿ, ಮೆಥಡ್ ರೆಸಲ್ಯೂಶನ್ ಆರ್ಡರ್ (MRO) ಮುಖ್ಯವಾಗುತ್ತದೆ. Child(Father, Mother) ನಲ್ಲಿ Father ಮೊದಲು ಇರುವುದರಿಂದ, Father ನ ಮೆಥಡ್‌ಗಳಿಗೆ ಆದ್ಯತೆ ಸಿಗುತ್ತದೆ.

3. ಮಲ್ಟಿಲೆವೆಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ (Multilevel Inheritance)

ಒಂದು ಕ್ಲಾಸ್ ಮತ್ತೊಂದು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ನಿಂದ ಇನ್ಹೆರಿಟ್ ಆಗುತ್ತದೆ.

ಉದಾಹರಣೆ:

class Grandfather:
    def own_house(self):
        print("ಅಜ್ಜನಿಗೆ ಸ್ವಂತ ಮನೆ ಇದೆ.")

class Father(Grandfather):
    def own_car(self):
        print("ತಂದೆಗೆ ಸ್ವಂತ ಕಾರು ಇದೆ.")

class Son(Father):
    def own_bike(self):
        print("ಮಗನಿಗೆ ಸ್ವಂತ ಬೈಕ್ ಇದೆ.")

# ಆಬ್ಜೆಕ್ಟ್ ರಚಿಸುವುದು
s = Son()
s.own_house()  # Grandfather ಕ್ಲಾಸ್‌ನಿಂದ
s.own_car()    # Father ಕ್ಲಾಸ್‌ನಿಂದ
s.own_bike()   # Son ಕ್ಲಾಸ್‌ನಿಂದ

ಔಟ್‌ಪುಟ್:

ಅಜ್ಜನಿಗೆ ಸ್ವಂತ ಮನೆ ಇದೆ.
ತಂದೆಗೆ ಸ್ವಂತ ಕಾರು ಇದೆ.
ಮಗನಿಗೆ ಸ್ವಂತ ಬೈಕ್ ಇದೆ.

4. ಹೈರಾರ್ಕಿಕಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ (Hierarchical Inheritance)

ಒಂದೇ ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನಿಂದ ಹಲವು ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ಗಳು ಇನ್ಹೆರಿಟ್ ಆಗುತ್ತವೆ.

ಉದಾಹರಣೆ:

class Vehicle:
    def info(self):
        print("ಇದು ಒಂದು ವಾಹನ.")

class Car(Vehicle):
    def type(self):
        print("ಇದು ಒಂದು ಕಾರು.")

class Bike(Vehicle):
    def type(self):
        print("ಇದು ಒಂದು ಬೈಕ್.")

# ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು
car = Car()
bike = Bike()

car.info()
car.type()

bike.info()
bike.type()

ಔಟ್‌ಪುಟ್:

ಇದು ಒಂದು ವಾಹನ.
ಇದು ಒಂದು ಕಾರು.
ಇದು ಒಂದು ವಾಹನ.
ಇದು ಒಂದು ಬೈಕ್.

super() ಫಂಕ್ಷನ್

super() ಫಂಕ್ಷನ್ ಚೈಲ್ಡ್ ಕ್ಲಾಸ್‌ನಿಂದ ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನ ಮೆಥಡ್‌ಗಳನ್ನು ಕರೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇದು ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ನಿರ್ವಹಣಾತ್ಮಕ ಮತ್ತು ಓದಬಲ್ಲಂತೆ ಮಾಡುತ್ತದೆ.

ಉದಾಹರಣೆ:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class Employee(Person):
    def __init__(self, name, age, emp_id):
        # ಪೇರೆಂಟ್ ಕ್ಲಾಸ್‌ನ __init__ ಅನ್ನು ಕರೆಯಲು super() ಬಳಸುವುದು
        super().__init__(name, age)
        self.emp_id = emp_id

    def display(self):
        print(f"ಹೆಸರು: {self.name}, ವಯಸ್ಸು: {self.age}, ಉದ್ಯೋಗಿ ID: {self.emp_id}")

emp = Employee("ಗೋವರ್ಧನ್", 30, "E123")
emp.display()

ಔಟ್‌ಪುಟ್:

ಹೆಸರು: ಗೋವರ್ಧನ್, ವಯಸ್ಸು: 30, ಉದ್ಯೋಗಿ ID: E123

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, Employee ಕ್ಲಾಸ್‌ನ __init__ ನಲ್ಲಿ super().__init__(name, age) ಎಂದು ಕರೆಯುವ ಮೂಲಕ Person ಕ್ಲಾಸ್‌ನ __init__ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳಲಾಗಿದೆ. ಇದು self.name = name ಮತ್ತು self.age = age ಎಂದು ಪುನಃ ಬರೆಯುವುದನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.