Hierarchical Inheritance with Examples in
Python
In the world of object-oriented programming, inheritance is a powerful concept that allows one
class to inherit the properties and behaviors of another. Hierarchical Inheritance is a specific form
of inheritance in Python that involves a single base class with multiple derived classes. This
article explores the concept of Hierarchical Inheritance, its syntax, advantages, and provides
three examples to illustrate its application in Python.
What is Hierarchical Inheritance?
Hierarchical Inheritance is a type of inheritance in which a single base class is inherited by
multiple derived classes. In this scenario, each derived class shares common attributes and
methods from the same base class, forming a hierarchy of classes.
Syntax :
class BaseClass:
# Base class attributes and methods
class DerivedClass1(BaseClass):
# Additional attributes and methods specific to DerivedClass1
class DerivedClass2(BaseClass):
# Additional attributes and methods specific to DerivedClass2
Hierarchical Inheritance Examples In Python
Below, are the Hierarchical Inheritance With Examples In Python.
Example 1: Animal Hierarchy
This Python code showcases hierarchical inheritance with a base class `Animal` and two derived
classes, `Dog` and `Cat`. The `Animal` class initializes a `name` attribute and has a placeholder
method `speak`. Both `Dog` and `Cat` inherit from `Animal`, providing their own
implementations of the `speak` method. Instances of `Dog` and `Cat` are created with specific
names, and their `speak` methods are called to print the sounds they make. In the example,
“Buddy says Woof!” and “Whiskers says Meow!” are printed.
class Animal:
def init (self, name): self.name = name
def speak(self): pass
class Dog(Animal): def speak(self):
return f"{self.name} says Woof!"
class Cat(Animal): def speak(self):
return f"{self.name} says Meow!"
# Usage
dog = Dog("Buddy") cat = Cat("Whiskers")
print(dog.speak())
print(cat.speak()) Output
Buddy says Woof!
Whiskers says Meow!
Example 2: Shape Hierarchy
In this example, below Python code defines a basic example of hierarchical inheritance with a
base class `Shape` and two derived classes, `Circle` and `Square`. The `Shape` class initializes a
color attribute and has a placeholder method for calculating area. Both `Circle` and `Square`
inherit from `Shape`, providing their own implementations of the `area` method. Instances of
`Circle` and `Square` are created with specific color and dimension parameters, and their `area`
methods are called to calculate and print the respective areas of a circle and a square.
class Shape:
def init (self, color): self.color = color
def area(self): pass
class Circle(Shape):
def init (self, color, radius): super(). init (color) self.radius = radius
def area(self):
return 3.14 * self.radius**2
class Square(Shape):
def init (self, color, side_length): super(). init (color)
self.side_length = side_length
def area(self):
return self.side_length**2
# Usage
circle = Circle("Red", 5)
square = Square("Blue", 4)
print(circle.area())
print(square.area())
Output
78.5
16
Example 3: Employee Hierarchy
In this example, below Python code demonstrates hierarchical inheritance with a base class
`Employee` and two derived classes, `Manager` and `Developer`. Each class initializes attributes
and has a `display_details` method. The `Manager` class includes a `team_size` attribute, while
the `Developer` class has a `programming_language` attribute. Instances of both classes are
created, and their `display_details` methods are invoked to display specific information about a
manager and a developer.
class Employee:
def init (self, name, salary): self.name = name
self.salary = salary
def display_details(self):
return f"Name: {self.name}, Salary: {self.salary}"
class Manager(Employee):
def init (self, name, salary, team_size): super(). init (name, salary)
self.team_size = team_size
def display_details(self):
return f"{super().display_details()}, Team Size: {self.team_size}"
class Developer(Employee):
def init (self, name, salary, programming_language): super(). init (name,
salary) self.programming_language = programming_language
def display_details(self):
return f"{super().display_details()}, Language:
{self.programming_language}"
# Usage
manager = Manager("John", 80000, 10)
developer = Developer("Alice", 60000, "Python")
print(manager.display_details()) print(developer.display_details())
Output
Name: John, Salary: 80000, Team Size: 10
Name: Alice, Salary: 60000, Language: Python
Advantages
Code Reusability: Hierarchical Inheritance promotes code reusability by allowing multiple
derived classes to inherit common functionalities from a single base class.
LogicalOrganization: It provides a logical and structured organization of classes, making the
code more readable and maintainable.
Flexibilityand Extensibility: Changes made to the base class automatically reflect in all
derived classes, offering flexibility and ease of extending functionalities.
Reduced Redundancy: Common attributes and methods are defined only once in the base
class, reducing redundancy and minimizing the chance of errors.
Conclusion
Hierarchical Inheritance in Python is a valuable feature that enhances code organization,
reusability, and flexibility. By understanding its syntax, advantages, and exploring real-world
examples, developers can make informed decisions on when and how to apply Hierarchical
Inheritance in their projects, contributing to more efficient and maintainable code.
