Method Overloading and Overridding

Overloading and Overriding are the 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 about 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 behaviours have totally different implementation but intended for 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 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 expense may be).

   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 got the point to use overriding, means, if your class's behaviors have anything is common and can be shared with other derived forms of classes then they should be overidden.