What is Polymorphism?

What is Polymorphism in OOPS?

Polymorphism is a key object-oriented programming (OOP) notion that enables developers to design flexible and reusable code. This fascinating feature of OOP allows objects of various classes to be considered instances of a common superclass. Polymorphism allows us to do several operations using a single interface, making it a valuable tool for improving code modularity, flexibility, and maintainability.

Polymorphism, derived from the Greek words "poly" for "many" and "morph" for "form", refers to an object's ability to take on multiple forms. It enables objects of the same class or type to respond differently to the same message or method call. This capability originates from the inheritance principle, which states that subclasses inherit traits and behaviors from a superclass, allowing them to override or enhance these characteristics to meet their needs.

Types of Polymorphism:

1. Static Polymorphism (Compile-time Polymorphism):

Function and operator overloading is used to achieve static polymorphism. When many functions have the same name but differ in their parameter types or the amount of parameters they accept, this is called function overloading. In contrast, operator overloading allows operators to be redefined for individual classes, allowing them to execute bespoke tasks.

2. Dynamic Polymorphism (Runtime Polymorphism):

Method overriding and virtual functions implement dynamic polymorphism. Method overriding occurs when a subclass implements a method specified in its superclass. This permits subclass objects to be treated as superclass instances, giving flexibility in using diverse classes inside a shared interface. Virtual functions are critical in enabling this behavior by permitting late binding, which determines the proper method implementation at runtime.

Benefits of Polymorphism:

• Code Reusability: Polymorphism allows us to reuse code by invoking methods via a common interface, which reduces code duplication and improves modularity.
• Flexibility: By considering objects of multiple classes as instances of a superclass, we may build generic code that works with various objects, enhancing flexibility and adaptability.
• Maintenance: Polymorphism improves cleaner code by decoupling object behavior from specific implementations. This reduces code maintenance and improves readability.
• Extensibility: Polymorphism allows for creating new classes without altering existing code. New subclasses can be easily incorporated into the system, allowing for easy extension.

Example of Polymorphism in OOPS

Let's look at an example employing the shapes Circle, Triangle, and Rectangle to understand polymorphism better. Classes in object-oriented programming languages such as Java or Python can be used to represent these shapes. To compute the area of each shape, we'll build a common superclass called Shape with a method called calculateArea(). Each shape class (Circle, Triangle, and Rectangle) will inherit from the Shape class and override the calculateArea() method with its implementation.

Here's an example in Python:

In the above example, we specify the common interface calculateArea() in the Shape class, and each derived class implements it independently. Polymorphic behavior is achieved by constructing a list of Shape objects and running the calculateArea() method on each shape. Regardless of the reference type provided, the appropriate calculateArea() method is based on the object's actual type at runtime.

Types of Polymorphism in OOPS

In this section, we will look at the many types of polymorphism in OOP and examples that demonstrate their use and benefits.

Ad hoc Polymorphism:

Ad hoc polymorphism, also known as function overloading or method overloading, allows for alternative implementations of the same method or function name based on the number of arguments, type, or both. This type of polymorphism assists developers in providing intuitive and readable interfaces while adapting to various use cases. Example: Consider the Calculator class, which has a method called add() that can perform addition for many sorts of operands, such as integers, floating-point values, or texts. We can handle diverse parameter types gracefully by overloading the add() method:

Parametric Polymorphism:

Developers can design code that can operate on values of many kinds thanks to parametric polymorphism, often known as generic programming. It isolates common functions, allowing for code reuse while assuring type safety. Example: Generic classes can provide parametric polymorphism in several programming languages, including Java and C++. Consider the following example of a generic class called Container that may hold any value:

We can build instances of Container for multiple types, such as ContainerInteger> or ContainerString>, but the underlying implementation remains the same, by utilizing the generic type argument T.

Inclusion Polymorphism:

Inclusion polymorphism, or subtype or runtime polymorphism, allows objects from distinct classes to be considered as instances of their common superclass. Because of this polymorphic behavior, dynamic method dispatch is possible, in which the proper method implementation is decided at runtime based on the actual object type. Example: Consider the following scenario: we have a base class called Shape and two derived classes, Circle and Rectangle. Each derived class overrides the calculateArea() method to compute the area according to its shape. They can, however, be stored and operated on using a reference to the base class Shape:

Explanation

We can generate diverse shapes by treating instances of Circle and Rectangle as Shape and calling the calculateArea() method on each object without explicitly knowing its exact type.

Important Concepts about Polymorphism in OOPS

Polymorphism, derived from the Greek words "poly" (many) and "morphos" (shape), refers to an object's ability to adopt numerous forms or display varied behaviors. It allows objects of distinct classes to be considered objects of a similar superclass, increasing code flexibility and decreasing dependencies.

There are two types of polymorphism: compile-time (or static) polymorphism and runtime (or dynamic) polymorphism. Each type serves a particular purpose and contributes to OOP's overall adaptability.

Compile-time Polymorphism - Method and operator overloading are used to achieve compile-time polymorphism. Thanks to method overloading, multiple methods with the same name but different argument lists can coexist within a class. The proper technique is chosen during compilation based on the amount, types, and sequence of arguments provided. Operator overloading, however, allows operators like +, -, *, or = to behave differently depending on the operands involved.

Runtime Polymorphism - Method overriding provides runtime polymorphism, also known as dynamic polymorphism. Method overriding happens when a subclass implements a method already defined in its superclass. The correct version of the method is executed at runtime based on the actual type of the object, not the reference type. This allows for flexibility and extensibility in OOP systems, enabling developers to design classes that can be easily extended and specialized.

Benefits of Polymorphism:

Polymorphism provides three major advantages that improve the efficiency and maintainability of software systems:

• Code Reusability: Polymorphism enables developers to reuse existing code by treating objects of different classes as belonging to a shared superclass. This encourages modular architecture and reduces code duplication, resulting in more efficient and concise code bases.
• Flexibility and Extensibility: Polymorphic code can adapt to different data types and behaviors, allowing flexible and extensible systems to be developed. Developers can introduce new functionality without altering current code by exploiting runtime polymorphism, boosting scalability, and lowering the chance of introducing problems.
• Simplified Implementation: Polymorphism makes complex system implementation easier by abstracting away specific aspects. Developers can design systems that are easier to understand, test, and maintain by focusing on common interfaces and behaviors.
• Polymorphic Collections: Polymorphism is important in the design of data structures like arrays, lists, and maps because it allows them to accommodate items of diverse types. This makes creating dynamic data structures that adapt to changing needs and requirements easier.

Advantages of Using Polymorphism

Let us now discuss some of the advantages provided by Polymorphism.

• Polymorphism enables code reusability and flexibility by designing a base class and allowing derived classes to inherit and modify its methods. Example:

• Polymorphism simplifies code maintenance by making modifications in the base class automatically propagate to derived classes. Example:

• Polymorphism enhances extensibility by allowing updates in the base class or the creation of new derived classes. Example:

• Polymorphism improves code readability by expressing distinct objects and behaviors using polymorphic constructs. Example:

• Polymorphism plays a crucial role in software design patterns such as Strategy, Factory, and Adapter, enhancing code reuse and modularity. Example: