Introduction to polymorphism

Polymorphism is a fancy word that means many shapes. In programming, it refers to the ability of different classes to share the same method name but behave differently. So, even though different objects (like a dog or a cat) might use the same method name speak(), each one can act differently!

 

It’s like having a universal remote that can control different types of devices (TV, music player, etc.)—but each device responds in its own way when you press the button.

Two types of Polymorphism

• Method Overloading (not common in Python but worth mentioning):

  • This is when you have multiple methods with the same name but different parameters. The method behaves differently based on the arguments passed to it.

• Method Overriding (which we already discussed!):

  • This is when a child class overrides a method from the parent class to provide its own version.

But in Python, method overloading is not directly supported as it is in some other languages. Python focuses more on method overriding.

Polymorphism in action with method overriding

Let's focus on method overriding in polymorphism.

In this case, the same method name speak() can be used by different classes, but each class will do something different with it.

Example with animals:

# Parent class
class Animal:
    def speak(self):
        return "I make a sound"

# Child class Dog
class Dog(Animal):
    def speak(self):
        return "Woof!"

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

In this example:

• The Animal class has a speak() method.
• The Dog and Cat classes both override the speak() method to give their own versions.

Using Polymorphism:

Now, let’s say you create both a Dog and a Cat. Even though both objects share the speak() method, each one responds differently when you call it.

# Create instances
dog = Dog()
cat = Cat()

# Call speak() on both
print(dog.speak())  # Output: Woof!
print(cat.speak())  # Output: Meow!

Both dog and cat are using the speak() method, but each class provides a different behavior. This is polymorphism!

Why is Polymorphism useful?

• Flexibility: You can use the same method name for different types of objects, which makes the code cleaner and easier to read.
• Extendability: As you create more specific classes, you can easily add new behaviors to the same method name.
• Interchangeable objects: You can handle different objects (like Dog or Cat) in the same way, making your code more generic and reusable.

Real-world example: Polymorphism in action

Imagine you have a game where you control different characters. All characters can attack, but each one has its own style of attack.

class Character:
    def attack(self):
        print("Generic attack!")

class Warrior(Character):
    def attack(self):
        print("Warrior swings a sword!")

class Mage(Character):
    def attack(self):
        print("Mage casts a spell!")

Now, when you call attack() on different characters:

warrior = Warrior()
mage = Mage()

warrior.attack()  # Output: Warrior swings a sword!
mage.attack()     # Output: Mage casts a spell!

Even though both warrior and mage are characters and have an attack() method, they perform it differently. This is polymorphism in action!