Creating a child class
Creating a child class (or subclass) in Python allows you to extend or customize the behavior of a parent class (or superclass). This enables code reuse while adding or modifying specific functionalities. Here’s a detailed guide on creating a child class, including in-depth explanations and examples.
Introduction to Inheritance
Inheritance is a mechanism that allows a class (the child class) to inherit attributes and methods from another class (the parent class). It creates an “is-a” relationship between classes.
Basic Example:
class Animal: def __init__(self, name, age): self.name = name self.age = age def speak(self): return "Animal sound"
In this example, Animal is a parent class.
Creating a Child Class
To create a child class in Python, you specify the parent class in parentheses when defining the child class. The child class inherits the attributes and methods of the parent class.
Example:
class Dog(Animal):
def __init__(self, name, age, breed):
super().__init__(name, age) # Call the constructor of the parent class
self.breed = breed
def speak(self):
return "Woof!"
def describe(self):
return f"{self.name} is a {self.breed} and is {self.age} years old."
- Defining the Child Class: class Dog(Animal) indicates that Dog is a subclass of Animal.
- Child Class Constructor: The __init__ method of Dog calls the parent class constructor using super(). It also initializes an additional attribute breed.
Using the super() Function
The super() function is used to call methods from the parent class within the child class. This is particularly useful for reusing code from the parent class’s constructor and extending or modifying inherited behavior.
Example:
class Cat(Animal):
def __init__(self, name, age, color):
super().__init__(name, age) # Call the parent class constructor
self.color = color
def speak(self):
return "Meow!"
def show_details(self):
return f"{self.name} is a {self.color} cat and is {self.age} years old."
- Calling the Parent Constructor: super().__init__(name, age) initializes the inherited attributes.
- Method speak: Overrides the parent method to provide cat-specific behavior.
Adding Child-Specific Methods and Attributes
You can add methods and attributes that are specific to the child class and not present in the parent class.
Example:
class Bird(Animal):
def __init__(self, name, age, species):
super().__init__(name, age)
self.species = species
def speak(self):
return "Chirp!"
def fly(self):
return f"{self.name} is flying in the sky."
def show_details(self):
return f"{self.name} is a {self.species} and is {self.age} years old."
- Method fly: Adds behavior specific to birds.
- Method show_details: Combines inherited information with bird-specific attributes.
Overriding Parent Methods
You can override methods inherited from the parent class to change or extend their behavior. This is called method overriding.
Example:
class Fish(Animal):
def __init__(self, name, age, type_of_fish):
super().__init__(name, age)
self.type_of_fish = type_of_fish
def speak(self):
return "Blub blub!"
def show_details(self):
return f"{self.name} is a {self.type_of_fish} and is {self.age} years old."
- Method speak: Overrides the parent method to provide a fish-specific sound.
- Method show_details: Provides details specific to fish.
Accessing Parent Class Attributes
Attributes defined in the parent class can be accessed and modified directly from the child class.
Example:
class Reptile(Animal):
def __init__(self, name, age, habitat):
super().__init__(name, age)
self.habitat = habitat
def show_details(self):
return f"{self.name} is a reptile, {self.age} years old, living in {self.habitat}."
- Attribute habitat: Specific to reptiles, but you can access and use inherited attributes (name and age).
Examples of Creating and Using Child Classes
Here’s how you can create and use instances of child classes.
Complete Example:
class Animal:
def __init__(self, name, age):
self.name = name
self.age = age
def speak(self):
return "Animal sound"
class Dog(Animal):
def __init__(self, name, age, breed):
super().__init__(name, age)
self.breed = breed
def speak(self):
return "Woof!"
def describe(self):
return f"{self.name} is a {self.breed} and is {self.age} years old."
# Creating an instance of Dog
my_dog = Dog("Rex", 5, "Labrador")
print(my_dog.speak()) # Woof!
print(my_dog.describe()) # Rex is a Labrador and is 5 years old.
- Instance my_dog: Uses methods from Dog as well as inherited attributes from Animal.
Multiple Inheritance (Advanced)
Python supports multiple inheritance, where a class can inherit from multiple parent classes. This can make the code more complex and requires understanding of Method Resolution Order (MRO).
Example:
class Animal: def speak(self): return "Animal sound" class Flying: def fly(self): return "I can fly!" class Bird(Animal, Flying): pass # Creating an instance of Bird my_bird = Bird() print(my_bird.speak()) # Animal sound print(my_bird.fly()) # I can fly!
- Multiple Inheritance: Bird inherits from both Animal and Flying, combining their behaviors.
Summary
- Creating a Child Class: Use class Child(Parent) to define a child class.
- Constructor: Use super() to call the parent class constructor.
- Child-Specific Methods: Add methods and attributes unique to the child class.
- Overriding Methods: Replace inherited methods to change their behavior.
- Accessing Parent Attributes: Use attributes from the parent class directly in the child class.
- Multiple Inheritance: Combine multiple parent classes to extend functionality, but be aware of potential complexity and MRO.