Inheritance (OOP)

Overview

Inheritance is a key principle of Object-Oriented Programming (OOP) that enables a new class to inherit attributes and methods from an existing class. The main purpose of inheritance is to promote code reuse and hierarchical relationships between classes, which helps organise and simplify code. With inheritance, programmers can create specialised classes based on more general classes, building on existing functionality without duplicating code.

Key Concepts of Inheritance

Parent and Child Classes

• The parent class (also called the superclass or base class) is the existing class from which attributes and methods are inherited.
• The child class (also known as the subclass or derived class) inherits attributes and methods from the parent class but can also have its own unique attributes and methods.

class Animal:         # Parent class
    def speak(self):
        print("The animal makes a sound.")

class Dog(Animal):    # Child class
    pass

Purpose of Inheritance

• Code Reuse: Inheritance allows child classes to use the attributes and methods of the parent class without rewriting the code, saving time and reducing duplication.
• Hierarchy and Specialisation: Inheritance enables the creation of a class hierarchy, where general classes can be extended into more specific ones. This models real-world relationships, making the code easier to understand and maintain.
• Extendability: By building on an existing class, child classes can add or override methods, allowing programmers to extend and customise functionality as needed.

Inheritance in Action

In Python, inheritance is established by passing the parent class as a parameter to the child class.

class Dog(Animal):    # Dog inherits from Animal
    def bark(self):
        print("Woof woof!")

Method Overriding

Definition: Method overriding occurs when a child class provides a new implementation for a method that is already defined in the parent class. This allows the child class to modify or specialise the behaviour of an inherited method.

class Animal:
    def speak(self):
        print("The animal makes a sound.")

class Dog(Animal):
    def speak(self):   # Overriding speak method
        print("Woof woof!")

Using super()

Purpose: The super() function allows the child class to access methods or attributes from the parent class. This is especially useful when a child class overrides a method but still needs to use functionality from the parent class's version of that method.

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

class Dog(Animal):
    def __init__(self, species, breed):
        super().__init__(species)  # Calls the parent class's constructor
        self.breed = breed

Example: Animal Inheritance Hierarchy

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

    def speak(self):
        return "The animal makes a sound."

class Dog(Animal):
    def speak(self):  # Overriding speak method
        return "Woof woof!"

class Cat(Animal):
    def speak(self):  # Overriding speak method
        return "Meow!"

# Creating instances of each class
animal = Animal("Generic Animal")
dog = Dog("Buddy")
cat = Cat("Whiskers")

# Using inherited and overridden methods
print(animal.speak())  # Outputs: The animal makes a sound.
print(dog.speak())     # Outputs: Woof woof!
print(cat.speak())     # Outputs: Meow!

Benefits of Inheritance

1. Code Reusability: Shared behaviour in the parent class can be reused by all child classes, reducing code redundancy.
2. Extensibility: Inheritance allows child classes to extend or customise behaviours, making it easy to add new functionalities without modifying the parent class.
3. Hierarchical Organisation: Class hierarchies mirror real-world relationships, which makes code organisation and readability clearer.

Note Summary