Polymorphism
Polymorphism is one of the four fundamental principles of object-oriented programming (OOP) in C#. It allows objects of different types to be treated as instances of a common base type. This enables a single interface to be utilized with various underlying data types. In C#, there are two types of polymorphism:
- Compile-time polymorphism (also known as static polymorphism)
- Run-time polymorphism (also known as dynamic polymorphism)
Compile-Time Polymorphism
Compile-time polymorphism is achieved through method overloading and operator overloading. This form of polymorphism is resolved during the compilation of the code.
Example of Compile-Time Polymorphism
using System;
class Calculator
{
// Method to add two integers
public int Add(int a, int b)
{
return a + b;
}
// Overloaded method to add three integers
public int Add(int a, int b, int c)
{
return a + b + c;
}
// Overloaded method to add two doubles
public double Add(double a, double b)
{
return a + b;
}
}
class Program
{
static void Main()
{
Calculator calc = new Calculator();
Console.WriteLine(calc.Add(2, 3)); // Calls Add(int, int)
Console.WriteLine(calc.Add(1, 2, 3)); // Calls Add(int, int, int)
Console.WriteLine(calc.Add(2.5, 3.5)); // Calls Add(double, double)
}
}
Run-Time Polymorphism
Run-time polymorphism is achieved through method overriding. This type of polymorphism is resolved at run time. Method overriding allows a derived class to provide a specific implementation for a method that is already defined in its base class
Example of Run-Time Polymorphism
using System;
// Base class
class Animal
{
// Virtual method to be overridden in derived classes
public virtual void Speak()
{
Console.WriteLine("The animal makes a sound.");
}
// Method to display the animal's type
public void DisplayType()
{
Console.WriteLine("This is an animal.");
}
}
// Derived class
class Dog : Animal
{
// Overriding the Speak method
public override void Speak()
{
Console.WriteLine("The dog barks.");
}
// Method specific to Dog
public void Fetch()
{
Console.WriteLine("The dog fetches the ball.");
}
}
// Derived class
class Cat : Animal
{
// Overriding the Speak method
public override void Speak()
{
Console.WriteLine("The cat meows.");
}
// Method specific to Cat
public void Scratch()
{
Console.WriteLine("The cat scratches the furniture.");
}
}
class Program
{
static void Main()
{
// Create instances of Dog and Cat
Animal myDog = new Dog();
Animal myCat = new Cat();
// Demonstrate run-time polymorphism
myDog.Speak(); // Outputs: The dog barks.
myCat.Speak(); // Outputs: The cat meows.
// Demonstrate base class method
myDog.DisplayType(); // Outputs: This is an animal.
myCat.DisplayType(); // Outputs: This is an animal.
// Directly accessing methods specific to Dog and Cat
Dog specificDog = new Dog();
Cat specificCat = new Cat();
specificDog.Fetch(); // Outputs: The dog fetches the ball.
specificCat.Scratch(); // Outputs: The cat scratches the furniture.
}
}
Benefits of Polymorphism
- Code Reusability: Polymorphism enables code reuse by allowing a base class to manage common functionality while derived classes provide specific implementations.
- Maintainability: Code becomes easier to maintain and extend because changes in the base class automatically affect derived classes.
- Flexibility: Polymorphism enhances flexibility by permitting objects to be treated as instances of their base type, which facilitates easier integration and interaction among different objects.
- Dynamic Behavior: Polymorphism supports dynamic method binding at runtime, ensuring that the appropriate method implementation is called based on the actual object type.