Providing a blueprint for subclasses

Sure! Let’s dive into the concept of “Providing a blueprint for subclasses” with some fun and easy-to-understand Python examples. Imagine we’re creating a special recipe book where different chefs can create their own dishes, but they all follow a basic recipe template. This template tells them what ingredients and steps they must include in their dishes, even though each dish might be different.

Understanding the Blueprint Concept

In programming, a blueprint is like a template that defines the basic structure for other parts of the program. In Python, we use classes to create blueprints. When we want other classes to follow the blueprint, we create subclasses. The blueprint class is called the parent class, and the subclasses are called child classes.

The Parent Class

Let’s create a parent class called Animal. This class will be a blueprint for any animal.

class Animal:
    def __init__(self, name):
        self.name = name
    
    def make_sound(self):
        raise NotImplementedError("Subclass must implement this method")

    def move(self):
        raise NotImplementedError("Subclass must implement this method")

In this blueprint:

• Every animal has a ‘name‘.
• Every animal must be able to make a sound (‘make_sound‘ method).
• Every animal must be able to move (‘move‘ method).

The ‘NotImplementedError‘ tells us that this method should be provided by the child class.

Creating Subclasses

Now, let’s create two child classes: ‘Dog‘ and ‘Bird‘. These classes will follow the blueprint provided by the ‘Animal‘ class.

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

    def move(self):
        return "Runs on four legs"

class Bird(Animal):
    def make_sound(self):
        return "Chirp!"

    def move(self):
        return "Flies in the sky"

In these subclasses:

• The ‘Dog‘ class implements ‘make_sound‘ and ‘move‘ methods for a dog.
• The ‘Bird‘ class implements ‘make_sound‘ and ‘move‘ methods for a bird.

Using Our Subclasses

Let’s create some objects from our subclasses and see them in action.

dog = Dog("Buddy")
bird = Bird("Tweety")

print(f"{dog.name} goes {dog.make_sound()} and {dog.move()}.")
print(f"{bird.name} goes {bird.make_sound()} and {bird.move()}.")

This will output:

Buddy goes Woof! and Runs on four legs.
Tweety goes Chirp! and Flies in the sky.

Practice Questions

Now it’s your turn! Try these exercises to practice creating your own subclasses.

1. Create a ‘Fish‘ Class
   • Follow the 'Animal‘ blueprint.
   • Implement ‘make_sound‘ (e.g., “Blub”).
   • Implement ‘move‘ (e.g., “Swims in the water”).
2. Create a ‘Cat‘ Class
   • Follow the ‘Animal‘ blueprint.
   • Implement ‘make_sound‘ (e.g., “Meow”).
   • Implement ‘move‘ (e.g., “Walks gracefully”).

Solutions

Here are the solutions to the practice questions.

1. Fish Class Solution

class Fish(Animal):
    def make_sound(self):
        return "Blub"

    def move(self):
        return "Swims in the water"

fish = Fish("Nemo")
print(f"{fish.name} goes {fish.make_sound()} and {fish.move()}.")

2. Cat Class Solution

class Cat(Animal):
    def make_sound(self):
        return "Meow"

    def move(self):
        return "Walks gracefully"

cat = Cat("Whiskers")
print(f"{cat.name} goes {cat.make_sound()} and {cat.move()}.")

This will output:

Nemo goes Blub and Swims in the water.
Whiskers goes Meow and Walks gracefully.

By creating a parent class with essential methods and attributes, we provide a blueprint for our subclasses. Each subclass can then define its own specific behavior while following the structure of the parent class. This helps keep our code organized and ensures that all subclasses have a consistent interface. Happy coding!