Method Overloading and Overriding

Introduction

Overloading and Overriding are parts of Polymorphism.
Overloading is compile time polymorphism, also known as Early Binding or Static Binding.
Overriding is run-time polymorphism, also known as Late Binding or Dynamic Binding.

So first we'll go through the Overloading

Suppose you need to define a method, but you don't have any idea of how many parameters would be there and also don't know the what type of data it would be.

Let's take a method named Insert_Employee.

 class Insert_Employee_Data

     public static void Insert_Employee(int EmployeeID)

       // Inserts EmployeeID as given and Employee's FirstName and LastName as empty

     public static void Insert_Employee(int EmployeeID, string FirstName)

       // Inserts EmployeeID and Employee Name as given whereas, LastName as empty

     public static void Insert_Employee(int EmployeeID, string FirstName, string LastName)

       // Inserts EmployeeID, Employee's FisrtName and LastName as given

When your class's behaviors have totally different implementation but are intended for a single target then use Overloading.

Now let's go through Overriding

Take a situation where you need to use the base class's method in a derived class with some add-on.

Suppose you have a price calculation class, which calculates the price and returns it to you.

The price calculation method should be declared as virtual, so that enhancements can be done to it later on (adding some expenses maybe).

class Price_Calculation
{
public decimal UnitPrice { get; set; }
private int Quantity { get; set; }
public virtual decimal CalculatePrice()
{
return (UnitPrice * Quantity);
}
}
/// <summary>
/// This class also calculates the Price Amount but returns the total amount with Expenses also
/// </summary>
class Price_And_Expense_Calculation : PriceCalculation
{
public decimal ExpenseAmount { get; set; }
/// This method does not calculate the price itself, but overrideds the price calculation method and just
/// adds the expense amount to it
public override decimal CalculatePrice()
{
return (base.CalculatePrice() + ExpenseAmount);
}
}

I hope you now understand overriding. It means, if your class's behaviors have anything in common and can be shared with other derived forms of classes then they should be overridden.