Overriding Methods: Inheritance in Python

Method overriding in Python allows a subclass to provide a specific implementation of a method that is already defined in its parent class. This is a key concept in inheritance, enabling polymorphism and customization of behavior. In this article, we will discuss method overriding with examples.

What is Method Overriding?

Method overriding occurs when a subclass defines a method with the same name as a method in its parent class. The method in the subclass overrides the method in the parent class, and when the method is called on an object of the subclass, the subclass's version of the method is executed.

Example 1: Basic Method Overriding

    class Animal:
        def speak(self):
            return "I make some sound."

    class Dog(Animal):
        def speak(self):
            return "Woof! Woof!"

    animal = Animal()
    print(animal.speak())  # Output: I make some sound.

    dog = Dog()
    print(dog.speak())  # Output: Woof! Woof!

In this example, the Dog class overrides the speak method of the Animal class to provide its specific implementation.

Using super() in Overriding

The super() function can be used in an overridden method to call the method in the parent class. This is useful when you want to extend the behavior of the parent class's method instead of completely replacing it.

Example 2: Extending Parent Method

    class Vehicle:
        def describe(self):
            return "This is a vehicle."

    class Car(Vehicle):
        def describe(self):
            description = super().describe()  # Call the parent class method
            return description + " It is a car."

    vehicle = Vehicle()
    print(vehicle.describe())  # Output: This is a vehicle.

    car = Car()
    print(car.describe())  # Output: This is a vehicle. It is a car.

In this example, the Car class extends the behavior of the describe method in the Vehicle class by calling it using super().

Overriding with Additional Attributes

Subclasses can override methods and use additional attributes or parameters specific to the subclass.

Example 3: Adding Subclass-Specific Behavior

    class Employee:
        def work(self):
            return "Performs general work."

    class Manager(Employee):
        def work(self):
            return "Manages the team and delegates tasks."

    class Developer(Employee):
        def work(self):
            return "Writes and maintains code."

    employee = Employee()
    print(employee.work())  # Output: Performs general work.

    manager = Manager()
    print(manager.work())  # Output: Manages the team and delegates tasks.

    developer = Developer()
    print(developer.work())  # Output: Writes and maintains code.

In this example, different subclasses provide specific implementations of the work method, demonstrating polymorphism.

Overriding with Initialization

Subclasses can override the __init__ method of the parent class to customize object initialization.

Example 4: Overriding __init__

    class Animal:
        def __init__(self, name):
            self.name = name

    class Bird(Animal):
        def __init__(self, name, can_fly):
            super().__init__(name)  # Call the parent class constructor
            self.can_fly = can_fly

        def details(self):
            return f"{self.name} can fly: {self.can_fly}"

    bird = Bird("Parrot", True)
    print(bird.details())  # Output: Parrot can fly: True

In this example, the Bird class overrides the __init__ method to add a new attribute, can_fly, while still initializing the name attribute using the parent class's constructor.

Key Points

  • Method overriding allows a subclass to redefine a method from its parent class.
  • Use super() to call the parent class's method in an overridden method.
  • Overriding enables polymorphism, where a single method call can have different behaviors depending on the object's type.
  • Always use the same method name in the subclass to ensure proper overriding.

Conclusion

Method overriding is a powerful feature in Python inheritance that enables flexibility and customization of behavior in subclasses. By understanding and using method overriding effectively, you can write more extensible and maintainable object-oriented programs.




Advertisement