Polymorphism in Object-Oriented Programming with Examples in C#

Polymorphism is a fundamental concept in object-oriented programming (OOP) that enables objects of different classes to be treated as instances of a common superclass or interface. This concept fosters code reuse, flexibility, and abstraction, making it an essential tool for software development. In this article, we will dive into the concept of polymorphism, and its advantages, and provide illustrative examples in C# to help you grasp its practical implementation.

Understanding Polymorphism: Polymorphism refers to the ability of an object to take on multiple forms. It allows objects of different types to be accessed and manipulated through a shared interface or superclass.

At its core, polymorphism allows developers to write code that can work with objects of diverse classes, as long as they conform to a common interface or inherit from a common superclass. This flexibility and extensibility empower developers to build more modular and adaptable software systems.

Polymorphism through Method Overriding: In C#, polymorphism is commonly achieved through method overriding. Method overriding occurs when a subclass defines a method that already exists in its superclass. By doing so, the subclass provides its own implementation of the method, effectively “overriding” the behavior defined in the superclass.

Let’s explore an example to understand polymorphism through method overriding in C#:

using System;

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("The animal makes a sound.");
    }
}

class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("The dog barks.");
    }
}

class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("The cat meows.");
    }
}

class MainClass
{
    public static void Main(string[] args)
    {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        animal1.MakeSound(); // Output: The dog barks.
        animal2.MakeSound(); // Output: The cat meows.
    }
}

In this example, we define an Animal class with a virtual method MakeSound(), which serves as a base implementation for subclasses. The Dog and Cat classes inherit from the Animal class and override the MakeSound() method with their own unique implementations.

Within the Main method, we create instances of Dog and Cat objects and assign them to variables of type Animal. When we invoke the MakeSound() method on these variables, the overridden methods in the respective subclasses are executed, resulting in the expected output.

Polymorphism through Method Overloading:

Another way to achieve polymorphism in C# is through method overloading. Method overloading occurs when a class defines multiple methods with the same name but different parameters. The appropriate method is chosen based on the arguments passed during invocation.

Consider the following example:

using System;

class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public double Add(double a, double b)
    {
        return a + b;
    }
}

class MainClass
{
    public static void Main(string[] args)
    {
        Calculator calculator = new Calculator();

        int result1 = calculator.Add(2, 3);
        Console.WriteLine("Result 1: " + result1); // Output: Result 1: 5

        double result2 = calculator.Add(2.5, 3.7);
        Console.WriteLine("Result 2: " + result2); // Output: Result 2: 6.2
    }
}

In this example, we have a Calculator class with two overloaded Add methods: one that takes two integers and another that takes two doubles. The appropriate method is automatically chosen based on the arguments provided during invocation.

In the Main method, we create an instance of the Calculator class and call the Add method with different argument types. The compiler determines the correct method to invoke based on the parameter types, resulting in the expected output.

Conclusion: Polymorphism is a powerful concept in object-oriented programming, enabling objects of different types to be treated uniformly through a shared interface or superclass. By embracing polymorphism, developers can achieve code reusability, extensibility, and flexibility in their software projects. The examples provided in C# demonstrate how polymorphism can be applied effectively through method overriding and overloading.