Single Inheritance in Python
Single inheritance is a fundamental concept in object-oriented programming (OOP) where a derived class (child class) inherits properties and behaviors (methods) from a single base class (parent class). This mechanism allows for code reuse, logical organization, and the creation of hierarchical relationships between classes.
Example of Single Inheritance
Let's look at an example to understand how single inheritance works in Python.
# Define the base class
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
return f"{self.name} makes a noise"
# Define the derived class
class Dog(Animal):
def speak(self):
return f"{self.name} barks"
# Create an instance of the derived class
dog = Dog("Buddy")
print(dog.speak()) # Output: Buddy barks
Explanation:
In this example, we have two classes: Animal
and Dog
. The Animal
class is the base class with an initializer method __init__
that sets the name of the animal and a method speak
that returns a string indicating the animal makes a noise. The Dog
class is the derived class that inherits from Animal
and overrides the speak
method to return a string indicating the dog barks.
Creating a Hierarchical Structure
Single inheritance allows the creation of a hierarchical structure where more specific classes inherit from more general classes. This helps in organizing code in a logical and meaningful way. For instance, consider the following example:
# Base class
class Vehicle:
def __init__(self, make, model):
self.make = make
self.model = model
def display_info(self):
return f"Vehicle: {self.make} {self.model}"
# Derived class
class Car(Vehicle):
def display_info(self):
return f"Car: {self.make} {self.model}"
car = Car("Toyota", "Corolla")
print(car.display_info()) # Output: Car: Toyota Corolla
Advantages of Single Inheritance
- Code Reusability: Methods and attributes defined in the base class can be reused in the derived class, reducing code duplication.
- Logical Structure: Establishes a clear and logical hierarchical structure, making the code easier to understand and maintain.
- Method Overriding: Allows the derived class to override methods of the base class to provide specific functionality.
Disadvantages of Single Inheritance
- Limited Reuse: Single inheritance restricts the derived class to inherit from only one base class, limiting reuse if multiple base classes have useful methods or attributes.
- Tight Coupling: The derived class is tightly coupled to the base class, meaning changes in the base class can affect the derived class.
Key Points
- Single inheritance involves a derived class inheriting from a single base class.
- The derived class can access and override methods and attributes of the base class.
- Helps in organizing code in a hierarchical manner.
- Provides benefits like code reuse, logical structure, and method overriding.
- Has some limitations like limited reuse and tight coupling.