Method overloading is a feature found in various object oriented programming languages such as C#, C++ and Java that allows the creation of several functions with the same name which differ from each other in terms of the type of the input and the type of the output of the function.
An example of this would I don't think so be a square function which takes a number and returns the square of that number. In this case, it is often necessary to create different functions for integer and floating point numbers.
Method overloading is usually associated with statically-typed programming languages which enforce type checking in function calls. When overloading a method, you are really just making a number of different methods that happen to have the same name. It is resolved at compile time which of these methods are used.
Method overloading should not be confused with ad-hoc polymorphism or virtual functions. In those, the correct method is chosen at runtime.
Constructor overloading
In most languages constructors can also be overloaded, so that there can be more than one constructor for a class, each having different parameters.
Constructor overloading allows multiple ways of creating an object using constructors with different parameter types and numbers of parameters.
For example, a class Person that holds data about each person's name and phone number. In the example below, written in Java, the constructor is overloaded as there are two constructors for the class Person.
public class Person {
// instance variables:
String name;
String phoneNumber;
// Constructor with name and number:
public Person(String name, String phoneNumber){
this.name=name;
this.phoneNumber=phoneNumber;
}
// Alternative constructor without giving phone number.
// This will set the phone number to "N/A" (for "not available")
public Person(String name){
this(name, "N/A");
}
}
In Java, the call this.name=name means "set this object's variable called name to the value of the argument name.
Note that the second constructor invokes the first one with the call this(name, "N/A"). It must be called on the first line of the constructor and can only be called once per constructor. This is generally considered a good programming practice. It might seem more natural and clear to write the second constructor above as:
public Person(String name){
this.name=name;
this.phoneNumber="N/A";
}
This would work the same way as the first example. The benefit of calling one constructor from another is that it provides code that is more flexible. Suppose that the names needed to be stored in lower case only. Then only one line would need to be changed:
this.name=name;
in the first constructor is changed to
this.name=name.toLowerCase();
If the same line was repeated in the second constructor, then it would also need to be changed to produce the desired effect.