Hybrid inheritance

Hybrid inheritance is a combination of two or more types of inheritance in a single program. It allows for more complex class hierarchies and greater flexibility in design by mixing different inheritance patterns such as single, multiple, multilevel, and hierarchical inheritance.

Key Concepts of Hybrid Inheritance

1. Base Class: The root class from which other classes may inherit.
2. Derived Classes: Classes that inherit properties and methods from one or more parent classes.
3. Combination: A mix of inheritance types (single, multiple, multilevel, hierarchical).

Why Use Hybrid Inheritance?

Hybrid inheritance is useful for:

• Complex Hierarchies: Modeling complex relationships and behaviors in a natural way.
• Code Reusability: Maximizing code reuse by leveraging multiple inheritance types.
• Flexibility: Creating more flexible and dynamic class designs.

Example of Hybrid Inheritance in Python

Let’s explore a practical example to understand hybrid inheritance better.

Step 1: Define the Base Class

class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(f"{self.name} is eating")

Step 2: Define the Intermediate Classes

class Mammal(Animal):
    def walk(self):
        print(f"{self.name} is walking")

class Bird(Animal):
    def fly(self):
        print(f"{self.name} is flying")

Step 3: Define a Derived Class Using Multiple Inheritance

class Bat(Mammal, Bird):
    def __init__(self, name):
        super().__init__(name)
    
    def hang(self):
        print(f"{self.name} is hanging upside down")

Step 4: Define Another Derived Class

class Dog(Mammal):
    def bark(self):
        print(f"{self.name} says Woof!")

Step 5: Instantiate and Use the Derived Classes

if __name__ == "__main__":
    bat = Bat("Bruce")
    dog = Dog("Buddy")

    # Using methods from the base and intermediate classes
    bat.eat()   # Output: Bruce is eating
    bat.walk()  # Output: Bruce is walking
    bat.fly()   # Output: Bruce is flying
    bat.hang()  # Output: Bruce is hanging upside down

    dog.eat()   # Output: Buddy is eating
    dog.walk()  # Output: Buddy is walking
    dog.bark()  # Output: Buddy says Woof!

Detailed Breakdown

1. Base Class Animal:
   • Initialization: The __init__ method initializes the name attribute.
   • eat Method: Prints a message indicating the animal is eating.
2. Intermediate Class Mammal:
   • Inherits the name attribute and eat method from the Animal class.
   • walk Method: Prints a message indicating the mammal is walking.
3. Intermediate Class Bird:
   • Inherits the name attribute and eat method from the Animal class.
   • fly Method: Prints a message indicating the bird is flying.
4. Derived Class Bat (Multiple Inheritance):
   • Inherits from both Mammal and Bird.
   • Inherits the name attribute, eat method, walk method, and fly method.
   • hang Method: Adds a new method specific to Bat.
5. Derived Class Dog:
   • Inherits from Mammal.
   • Inherits the name attribute, eat method, and walk method.
   • bark Method: Adds a new method specific to Dog.

Method Resolution Order (MRO)

In hybrid inheritance, the MRO determines the order in which methods are inherited and called. Python uses the C3 linearization algorithm to compute the MRO, ensuring a consistent and predictable order.

print(Bat.mro())
# Output: [<class '__main__.Bat'>, <class '__main__.Mammal'>, <class '__main__.Bird'>, <class '__main__.Animal'>, <class 'object'>]