Method overloading

From Wikipedia, the free encyclopedia

This article does not cite any references or sources.
Please help improve this article by adding citations to reliable sources. Unverifiable material may be challenged and removed.

This article contains instructions, advice, or how-to content.
The purpose of Wikipedia is to present facts, not to teach subject matter.
Please help improve this article by removing or rewriting the how-to content, which may qualify for a move to http://www.wikihow.com/ or http://howto.wikia.com/.

Method overloading is a feature found in various programming languages such as Ada, 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 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.

[edit] Constructor overloading

In some object oriented programming languages, constructors can also be overloaded. In languages that require constructors to have the same name as the declaring class, constructor overloading allows multiple ways of creating an object. The constructors must have different parameter types or numbers of parameters.

For example, the class Person below, written in Java, holds data about each person's name and phone number. 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: