Overloading vs Overriding
Polymorphism means “Many Forms”. In Polymorphism, poly means “Many” and morph means “Forms.” Polymorphism is one of the main pillars in Object-Oriented Programming. It allows you to create multiple methods with the same name but different signatures in the same class. The same name methods can also be in derived classes.
There are two types of Polymorphism,
- Method Overloading
- Method Overriding
In this article, I will explain method overloading and method overriding concepts in X++. I will try to demonstrate step-by-step differences between these.
Method Overloading
Method Overloading is a type of polymorphism. It has several names like “Compile Time Polymorphism” or “Static Polymorphism” and sometimes it is called “Early Binding”.
Method Overloading means creating multiple methods in a class with the same names but different signatures (Parameters). It permits a class, struct, or interface to declare multiple methods with the same name with unique signatures.
The compiler automatically calls the required method to check the number of parameters and their type which are passed into that method.
Sample Code
public class Program
{
public int Add(int num1, int num2)
{
return (num1 + num2);
}
public int Add(int num1, int num2, int num3)
{
return (num1 + num2 + num3);
}
public float Add(float num1, float num2)
{
return (num1 + num2);
}
public string Add(string value1, string value2)
{
return (value1 + " " + value2);
}
static void Main(Args _args)
{
Program objProgram = new Program();
Info("Add with two int parameter :" + objProgram.Add(3, 2));
Info("Add with three int parameter :" + objProgram.Add(3, 2, 8));
Info("Add with two float parameter :" + objProgram.Add(3 f, 22 f));
Info("Add with two string parameter :" + objProgram.Add("hello", "world"));
}
}
In the above example, you can see that there are four methods with the same name but the type of parameters or number of parameters is different. When you call Add(4,5), complier automatically calls the method which has two integer parameters and when you call Add(“hello”,” world”), complier calls the method which has two string parameters. So basically in method overloading complier checks which method should be called at the time of compilation.
Note: Changing the return type of method does not make the method overloaded. You cannot create method overloaded vary only by return type.
Method Overriding
Method Overriding is a type of polymorphism. It has several names like “Run-Time Polymorphism” or “Dynamic Polymorphism” and sometimes it is called “Late Binding”.
Method Overriding means having two methods with the same name and same signatures [parameters], one should be in the base class and another method should be in a derived class [child class]. You can override the functionality of a base class method to create the same name method with the same signature in a derived class. You can achieve method overriding using inheritance. Virtual and Override keywords are used to achieve method overriding.
class BaseClass
{
public virtual void Add(int num1, int num2)
{
// your logic will be here
}
}
class ChildClass: BaseClass
{
public override void Add(int num1, int num2)
{
// your logic will be here
;
}
}
class Program
{
static void Main(Args _args)
{
BaseClass baseClassObj;
baseClassObj = new BaseClass();
Info("Base class method Add :" + baseClassObj.Add(-3, 8));
baseClassObj = new ChildClass();
Info("Child class method Add :" + baseClassObj.Add(-2, 2));
}
}
In the above example, I have created two same name methods in the BaseClass as well as in the child class. When you call the BaseClass Add method with less than zero value as parameters then it adds successfully. But when you call the ChildClass Add method with less than zero value then it checks for a negative value. And the passing values are negative then it asks for a new value.
So, here it is clear that we can modify the base class methods in derived classes.
Points to be remembered,
- The method cannot be private.
- The only abstract or virtual method can be overridden.
- Which method should be called is decided at run time.
