Polymorphism is a fundamental concept in object-oriented programming that allows objects of different classes to be treated as objects of a common base class. It enables you to write more flexible and reusable code by allowing different classes to provide their own implementations of methods with the same name, typically through method overriding.
There are two main types of polymorphism in object-oriented programming:
- Compile-Time Polymorphism (Static Binding): Also known as method overloading, it occurs at compile time. In this case, the appropriate method to be called is determined at compile time based on the method signature (name and parameter types).
- Run-Time Polymorphism (Dynamic Binding): Also known as method overriding, it occurs at runtime. The decision about which method to call is made at runtime based on the actual type of the object.
Here’s an example of run-time polymorphism using method overriding in C++:
#include <iostream> class Animal { public: virtual void makeSound() { std::cout << "Some generic animal sound" << std::endl; } }; class Dog : public Animal { public: void makeSound() override { std::cout << "Bark" << std::endl; } }; class Cat : public Animal { public: void makeSound() override { std::cout << "Meow" << std::endl; } }; int main() { Animal* myAnimal; Dog myDog; Cat myCat; myAnimal = &myDog; myAnimal->makeSound(); // Calls Dog's makeSound method myAnimal = &myCat; myAnimal->makeSound(); // Calls Cat's makeSound method return 0; }
- We define a base class
Animal
with a virtual methodmakeSound()
. - We create two derived classes,
Dog
andCat
, which override themakeSound()
method with their own implementations. - In the
main()
function, we create instances ofDog
andCat
. - We use a pointer to the base class
Animal
to point to instances ofDog
andCat
. - When we call
makeSound()
through the pointer, it calls the appropriate method for the actual object’s type, demonstrating run-time polymorphism.
The ability to treat objects of different derived classes as objects of a common base class and have their methods behave according to their actual types is a powerful feature of polymorphism in object-oriented programming.