What is Polymorphism?

(Chat GPT) WhatsApp

[25/12, 11:00 pm] ChatGPT: *Polymorphism in Object-Oriented Programming (OOP)*

*Polymorphism* is one of the four fundamental principles of *Object-Oriented Programming

(OOP)*, along with *Encapsulation*, *Inheritance*, and *Abstraction*. Polymorphism allows
objects of different classes to be treated as objects of a common superclass, particularly when
they share common behavior. The term "polymorphism" comes from Greek words meaning
"many forms," which reflects the idea that one function or method can take on many forms.

In simpler terms, *polymorphism* allows different classes to provide different implementations of

methods that share the same name, enabling a common interface to interact with different
objects.

*Types of Polymorphism*

There are *two main types* of polymorphism in OOP:

1. *Compile-time Polymorphism (Static Polymorphism)*

2. *Run-time Polymorphism (Dynamic Polymorphism)*

*1. Compile-time Polymorphism (Static Polymorphism)*

Compile-time polymorphism is resolved during the *compilation* phase. The most common
types of compile-time polymorphism are:

- *Method Overloading*
- *Operator Overloading*

*Method Overloading*:
- *Method overloading* occurs when multiple methods in the same class have the same name
but differ in the number or types of parameters.
[25/12, 11:00 pm] ChatGPT: - The correct method is called based on the number or type of
arguments passed.

*Example of Method Overloading*:

```cpp
#include <iostream>
using namespace std;

class Print {
public:
void display(int i) {
cout << "Integer: " << i << endl;
}

void display(double d) {
cout << "Double: " << d << endl;
 }

void display(string s) {
cout << "String: " << s << endl;
}
};

int main() {
Print p;
p.display(5); // Calls display(int)
p.display(3.14); // Calls display(double)
p.display("Hello"); // Calls display(string)
return 0;
}
```
In this example, the *display()* method is overloaded to handle three types of inputs: integer,
double, and string.

*Operator Overloading*:
- *Operator overloading* allows the definition of custom behaviors for operators like `+`, `-`, `=`,
`*`, etc., when used with objects.
- This is specific to C++ and other languages that support operator overloading.

*Example of Operator Overloading*:

```cpp
#include <iostream>
using namespace std;

class Complex {
public:
int real, imag;

Complex operator + (Complex const &other) {

Complex temp;
temp.real = real + other.real;
temp.imag = imag + other.imag;
return temp;
}
};

int main() {
[25/12, 11:00 pm] ChatGPT: Complex c1, c2, c3;
c1.real = 3; c1.imag = 4;
c2.real = 1; c2.imag = 2;

c3 = c1 + c2; // Uses overloaded '+' operator

cout << "Sum: " << c3.real << " + " << c3.imag << "i" << endl;
return 0;
}
```
In this example, the `+` operator is overloaded to add two *Complex* objects.

*2. Run-time Polymorphism (Dynamic Polymorphism)*

Run-time polymorphism is resolved during the *execution* phase. It allows objects of different
classes to be treated as objects of a common superclass, with the appropriate method being
called based on the object type.

The key mechanism for achieving run-time polymorphism is *method overriding*, which occurs
in *inheritance* hierarchies.

*Method Overriding*:
- *Method overriding* occurs when a method in a base class is redefined (overridden) in a
derived class with the same signature (same name and parameters). The method in the derived
class provides a new implementation of the method.
- In run-time polymorphism, the method that gets called is determined at runtime based on the
actual object type, not the reference type.

*Example of Method Overriding*:

```cpp
#include <iostream>
using namespace std;

// Base Class
class Animal {
public:
virtual void sound() {
cout << "Animal makes a sound" << endl;
}
};
[25/12, 11:00 pm] ChatGPT: // Derived Class
class Dog : public Animal {
public:
void sound() override {
cout << "Dog barks" << endl;
}
};

// Another Derived Class

class Cat : public Animal {
public:
void sound() override {
cout << "Cat meows" << endl;
}
};
int main() {
Animal* animalPtr;

Dog dog;
Cat cat;

// Animal pointer pointing to Dog object

animalPtr = &dog;
animalPtr->sound(); // Output: Dog barks

// Animal pointer pointing to Cat object

animalPtr = &cat;
animalPtr->sound(); // Output: Cat meows

return 0;
}
```
In this example, the *sound()* method is overridden in both the *Dog* and *Cat* classes. The
*animalPtr* (of type `Animal*`) is used to refer to objects of different classes, but at *runtime*,
the appropriate method (`sound()`) is called depending on the actual object (`dog` or `cat`).

- *Virtual Functions*: In C++, for run-time polymorphism to work, the base class function should
be declared as `virtual`. This tells the compiler to use dynamic binding (late binding), ensuring
that the correct method is called based on the object type.

---

*Key Differences Between Compile-time and Run-time Polymorphism*

| Aspect | Compile-time Polymorphism | Run-time Polymorphism |

[25/12, 11:00 pm] ChatGPT:
|--------------------------|-------------------------------------|-----------------------------------|
| *Resolved* | At compile-time | At runtime |
| *Types* | Method Overloading, Operator Overloading | Method Overriding |
| *Binding* | Early Binding (Static Binding) | Late Binding (Dynamic Binding) |
| *Performance* | Faster, as the decision is made at compile-time | Slower, due to runtime
method lookup |
| *Examples* | Function overloading, Operator overloading | Virtual functions,
Inheritance |

---

*Advantages of Polymorphism*

1. *Code Reusability*: Polymorphism allows code to be reused across different classes, which
reduces redundancy.
2. *Flexibility*: Code that works with base class references can seamlessly interact with objects
of derived classes, making the code more flexible and extensible.
3. *Maintainability*: It simplifies code maintenance and extension since new derived classes can
be added without modifying the code that uses polymorphism.
4. *Improved Code Organization*: It allows a more organized code structure, as behavior can be
shared among multiple classes through inheritance and overridden methods.

---
[25/12, 11:00 pm] ChatGPT: *Real-World Examples of Polymorphism*

1. *Shape Drawing (Graphics Programs)*:

- A base class `Shape` with derived classes `Circle`, `Rectangle`, etc., can use polymorphism
to call the `draw()` method on different shapes without knowing the exact type of shape.

2. *Payment Processing Systems*:

- In a payment system, you may have a `PaymentMethod` base class, with derived classes
such as `CreditCard`, `DebitCard`, and `PayPal`. The same method `processPayment()` can be
called polymorphically, regardless of the type of payment method.

---

*Conclusion*

*Polymorphism* is a powerful concept in *Object-Oriented Programming* that enables flexibility,

reusability, and scalability in software design. Whether through *compile-time polymorphism*
(method and operator overloading) or *run-time polymorphism* (method overriding),
polymorphism allows objects to behave in different ways based on their type, leading to cleaner
and more maintainable code. It is one of the key features that make object-oriented
programming so powerful and widely used in modern software development.