Polymorhism

Polymorphism is another fundamental concept of object-oriented programming (OOP) that allows you to use a single name to refer to objects of different types, and have them behave differently based on their type or class. In other words, polymorphism allows you to write code that can work with objects of different classes in a generic way, without knowing their exact type.

In C#, polymorphism is achieved through two mechanisms: method overloading and method overriding.

Method overloading allows you to define multiple methods with the same name in a class, but with different parameters or parameter types. Here's an example:

class Calculator

{

    public int Add(int num1, int num2)

    {

        return num1 + num2;

    }

    public double Add(double num1, double num2)

    {

        return num1 + num2;

    }

}

In this example, the Calculator class defines two methods named Add(), but with different parameter types (integers and doubles). When you call the Add() method with integer arguments, the first method will be called, and when you call it with double arguments, the second method will be called. This is an example of method overloading.

Method overriding, on the other hand, allows a derived class to override the implementation of a method in the base class, providing its own implementation. Here's an example:

class Animal

{

    public virtual void MakeSound()

    {

        Console.WriteLine("Animal is making a sound.");

    }

}

class Dog : Animal

{

    public override void MakeSound()

    {

        Console.WriteLine("Dog is barking.");

    }

}

In this example, the Animal class defines a virtual method MakeSound(), which can be overridden by any derived class. The Dog class overrides the MakeSound() method with its own implementation, which outputs "Dog is barking." When you call the MakeSound() method on a Dog object, it will call the overridden method in the Dog class, not the base class. This is an example of method overriding.

Polymorphism allows you to write code that can work with objects of different classes in a generic way, without having to know their exact type. This can lead to more flexible and reusable code, and make it easier to maintain and extend your code over time.