Polymorphism Principle

Polymorphism is one of the 4 main OOP principles. It's the ability to take many forms.

Compile time Polymorphism

Compile time Polymorphism occurs in function overloading.

Example of function overloading - many functions with the same name that accept different arguments:

Result:

Runtime Polymorphism

Runtime Polymorphism occurs in function overriding .

This means that the base class has a function that's being overwritten in the children classes:

using System;

namespace ConsoleApp1
{

class Figure
    {
        // base class method that'll be overwritten:
        public double calcArea()
        {
            return 0;
        }
    }

class Square : Figure
    {
        private double side;

public Square(double sideValue)
        {
            side = sideValue;
        }

// overwriting base method:
        public double calcArea()
        {
            return side * side;
        }
    }

class Triangle : Figure
    {
        private double a;
        private double b;
        private double c;

public Triangle(double aVal, double bVal, double cVal)
        {
            a = aVal;
            b = bVal;
            c = cVal;
        }

// overwriting base method:
        public double calcArea()
        {
            double p = (a + b + c) / 2;
            double area = Math.Sqrt(p * (p - a) * (p - b) * (p - c));

return area;
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            Square square = new Square(2);
            Console.WriteLine("Square Area = " + square.calcArea());

Triangle triangle = new Triangle(3, 4, 5);
            Console.WriteLine("Triangle Area = " + triangle.calcArea());
        }
    }
}

Output:

The function calcArea in Figure class is overwritten by Square and Triangle classes.