Polymorphism in Object-Oriented Programming

Learn about polymorphism in object-oriented programming (OOP), including method overriding, runtime polymorphism, and how it enables flexible and extensible code structures.

Polymorphism in Object-Oriented Programming

---

General Concept

Polymorphism is a fundamental principle in object-oriented programming (OOP) that allows objects of different types to be treated as objects of a common base type. The word “polymorphism” comes from Greek, meaning “many forms.” In OOP, it refers to the ability of a single interface to represent different underlying forms (data types or classes).

Key Aspects of Polymorphism:

1. Same Interface, Different Implementations: Polymorphism allows different classes to have methods with the same name, but with different implementations.

2. Flexibility: It provides a way to use a class exactly like its parent, but with its own specific implementation.

3. Simplification: It simplifies programming interfaces, making code more modular and extensible.

4. Runtime Decision: The specific method that gets called is often determined at runtime, based on the actual type of the object.

Types of Polymorphism:

1. Compile-time Polymorphism (Static):
   • Achieved through method overloading
   • Resolved at compile time
2. Runtime Polymorphism (Dynamic):
   • Achieved through method overriding
   • Resolved at runtime

Example of Polymorphism:

Consider a base class Animal with a method make_sound(). Different animals can implement this method differently:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

class Animal:

    def make_sound(self):

        pass

class Dog(Animal):

    def make_sound(self):

        return "Woof!"

class Cat(Animal):

    def make_sound(self):

        return "Meow!"

class Cow(Animal):

    def make_sound(self):

        return "Moo!"

# Using polymorphism

animals = [Dog(), Cat(), Cow()]

for animal in animals:

    print(animal.make_sound())

In this example, each animal class implements the make_sound() method differently, but they can all be treated as Animal objects.

Method Overriding

Method overriding is a fundamental aspect of runtime polymorphism. It occurs when a derived class (child class) has a method with the same name and signature as a method in its base class (parent class).

Key Points about Method Overriding:

1. Same Name and Signature: The overriding method must have the same name and parameter list as the method in the parent class.

2. Runtime Decision: The method to be invoked is determined at runtime based on the object’s type.

3. Extends or Modifies Behavior: Overriding allows a child class to provide a specific implementation of a method that is already defined in its parent class.

4. Polymorphic Behavior: It’s a key mechanism for achieving polymorphic behavior in OOP.

Example of Method Overriding:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

class Shape:

    def area(self):

        return 0

class Rectangle(Shape):

    def __init__(self, width, height):

        self.width = width

        self.height = height

    

    def area(self):

        return self.width * self.height

class Circle(Shape):

    def __init__(self, radius):

        self.radius = radius

    

    def area(self):

        return 3.14 * self.radius ** 2

# Using method overriding

shapes = [Rectangle(5, 3), Circle(4), Shape()]

for shape in shapes:

    print(f"Area: {shape.area()}")

In this example: - The Shape class provides a default implementation of area(). - Rectangle and Circle override this method with their specific implementations. - We can treat all objects as Shape instances, but each will use its own area() method.

Benefits of Method Overriding:

1. Customization: Allows subclasses to provide specific implementations of methods.
2. Code Reusability: Reuses the method name from the parent class, maintaining a logical hierarchy.
3. Runtime Flexibility: Enables objects to behave differently based on their actual class, while still using a common interface.

Method overriding is a powerful feature that, when used correctly, can lead to more flexible and maintainable code structures in object-oriented programming.