Polymorphism

Polymorphism is the ability of different classes to be treated as instances of the same class through a common interface. It allows methods to do different things based on the object they’re acting upon, even though they share the same name.

Understanding Polymorphism

The word “polymorphism” comes from Greek meaning “many forms”. In programming, it means that objects of different types can be accessed through the same interface.

Types of Polymorphism

1. Duck Typing - “If it walks like a duck and quacks like a duck, it’s a duck”
2. Method Overriding - Subclasses override parent methods
3. Operator Overloading - Same operator works differently for different types

Duck Typing

Duck Typing in Python

Python uses duck typing - if an object has the required methods, it can be used regardless of its type. This is Python’s way of achieving polymorphism without explicit inheritance hierarchies.

Remember: “If it walks like a duck and quacks like a duck, it’s a duck!”

Polymorphism Through Inheritance

When classes inherit from a common base class, they can be used interchangeably:

classDiagram
    class Vehicle {
        +brand: str
        +model: str
        +year: int
        +start()* str
        +get_info() str
    }
    
    class Car {
        +start() str
    }
    
    class Motorcycle {
        +start() str
    }
    
    class ElectricVehicle {
        +start() str
    }
    
    Vehicle <|-- Car
    Vehicle <|-- Motorcycle
    Vehicle <|-- ElectricVehicle
    
    note for Vehicle "Polymorphism:\nSame interface,\ndifferent implementations"

Real-World Example: Payment Processing

Polymorphism with Abstract Classes

Using abstract classes ensures all implementations provide required methods:

Operator Overloading (Polymorphism)

The same operator can work differently for different types:

Real-World Example: Notification System

Benefits of Polymorphism

1. Code Reusability - Write code once, use with multiple types
2. Flexibility - Easy to add new types without changing existing code
3. Maintainability - Changes to one type don’t affect others
4. Simplicity - One interface for multiple implementations
5. Extensibility - Easy to extend functionality

Key Takeaways

Remember

• Polymorphism allows different classes to be used interchangeably through a common interface
• Duck typing - Python doesn’t care about type, only about having the right methods
• Method overriding - Subclasses provide their own implementations
• Operator overloading - Same operators work differently for different types
• Abstract classes ensure all implementations provide required methods
• Use polymorphism to write flexible, maintainable code that works with multiple types

Polymorphism is about flexibility - writing code that works with multiple types without knowing the specific type at compile time. It’s one of the most powerful features of object-oriented programming.