Polymorphism in C#

Polymorphism

 

Polymorphism means many forms (ability to take more than one form). In Polymorphism poly means “multiple” and morph means “forms” so polymorphism means many forms.

 

Polymorphism can be either static or dynamic. Based on the binding the method polymorphism can be differentiate into two types,

1. Static polymorphism
2. Dynamic Polymorphism 

Static Polymorphism :

The mechanism of linking a method with an object during compile time is called early binding. In static polymorphism the compiler will decide which method to be called.

 

Function overloading and operator overloading are the examples for static binding (or static polymorphism). 

 

Function overloading : 

The process of creating more than one method in a class with the same name is called function overloading.

While overloading methods, we need to follow the overloaded methods which must differ either in number of arguments they take or the data type of at least one argument.

Note : A method with the same name and same signature but with different return type can't be overloaded. 

class SumClass
{
    public int Sum(int A, int B)
    {
        return A + B;
    }

    public float Sum(float A, float B)
    {
        return A + B;
    }

    public int Sum(int A, int B, int C)
    {
        return A + B + C;

    }
}


class MainClass
{
    static void Main()
    {

        SumClass sumClass = new SumClass();

        Console.WriteLine("sum of 2 integers (10, 15) : " + sumClass.Sum(10, 15));

        Console.WriteLine("sum of 2 floats (2.3f, 5.4f) : " + sumClass.Sum(2.3f, 5.4f));

        Console.WriteLine("sum of 2 integers (10, 20, 50) : " + sumClass.Sum(10, 20, 50));

        Console.ReadKey();
    }

}

operator overloading :

Operator overloading allows user to redefine the meaning of the operator. Overloaded operators are functions with special names, the keyword operator followed by the symbol for the operator being defined. It has parameters and return value as well like any other method in c# class. 

class ComplexNumber
{
    public double RealPart;
    public double ImaginaryPart;

    public ComplexNumber(double realPart, double imaginaryPart)
    {
        RealPart = realPart;
        ImaginaryPart = imaginaryPart;
    }

    public ComplexNumber()
    {
        RealPart = 0;
        ImaginaryPart = 0;
    }

    // Overload + operator to add two Box objects.
    public static ComplexNumber operator +(ComplexNumber num1, ComplexNumber num2)
    {
        ComplexNumber result = new ComplexNumber();
        result.RealPart = num1.RealPart + num2.RealPart;
        result.ImaginaryPart = num1.ImaginaryPart + num2.ImaginaryPart;
        return result;
    }

    public void Display()
    {
        Console.WriteLine("number is : {0} + {1}i", RealPart, ImaginaryPart);
    }
}

class MainClass
{
    static void Main(string[] args)
    {
        ComplexNumber num1 = new ComplexNumber(2, 5);
        ComplexNumber num2 = new ComplexNumber(3, 7);
        ComplexNumber num3 = new ComplexNumber();

        // Add two object as follows:
        num3 = num1 + num2;

        num1.Display();
        num2.Display();
        num3.Display();

        Console.ReadKey();
    }
}

Please check Dynamic Polymorphism for dynamic polymorphism and virtual keyword in c#

 

Thanks for reading.