Why should I ever overload methods?

Question

I found two examples in my book of overloading methods, but it doesn't explain clearly exactly why it's useful:

package keepo;
public class Main{
    public static void main(String [] args)
    {
        int newScore = calculateScore("Tim", 500);
        System.out.println("New Score is" + newScore);
        calculateScore(75);

    }
    public static int calculateScore(String playerName, int score){
        System.out.println("Player" + playerName +"Has score" + score);
        return score * 1000;
    }
    public static int calculateScore(int score){
        System.out.println("Unnamed player scored" + score + "points");
        return score * 1000;
    }
}

This is pretty straightforward, but honestly it seems pretty useless to method overload here, and it seems just doing it for the sake of doing it.

The next example in the book does method overloading which seems a bit more useful, because that program calculates feet to centimeters, and there is one method where you can put in feet and inches, and one method where you can put inches. However, it still seems just as easy to make two separate methods for this.

That being said, are there any real benefits to doing this? (I read this, but I am not really to satisfied. It seems just as easy to make new methods.)

Answer 1

I think if you talk about the real benefits of function/method overloading, something without which you won't get your way around, then as you've pointed out in your question, you won't find any.

But how is it helpful? Let's consider this example.

Let's suppose that I'm making an application that finds a person by his name and I declare and define a method

public Person[] findPerson(String name)

Now we get a requirement where we've to find a person by his Date of Birth, so introduce a new method

public Person[] findPerson_byDOB(Date date)

Let's suppose this continues and we've this many methods in my application.

public Person[] findPerson(String name)
public Person[] findPerson_byDOB(Date date)
public Person[] findPerson_byAddress(Address address)
public Person[] findPerson_bySSN(SSN ssn)
public Person[] findPerson_byDepartment(Department department)
public Person[] findPerson_byMobile(Mobile mobile)

It's just one part; this can carry on when we are asked to introduce multiple parameters, like

public Person[] findPerson_byMobileAndAddress(Mobile mobile, Address address)
public Person[] findPerson_byAddressAndDepartment(Address address, Department department)
public Person[] findPerson_byDOBAndDepartment(DOB dob, Department, department)
public Person[] findPerson_byAddressAndDOB(Address address, DOB dob)

and many many more...

While this may seem a little bit exaggerated, trust me, when making an actual industry level application, we may come across a situation when we get hundreds and hundreds of methods like this, and ultimately we'll need a catalog of all these methods of what they actually do.

It is actually a nightmare when we'll have to find the name of all these methods when we would have to use it.

However, when all the parameters are different, we can give same name to the function and it really becomes very easy to remember.

public Person[] findPerson(String name)
public Person[] findPerson(Date date)
public Person[] findPerson(Address address)
public Person[] findPerson(SSN ssn)
public Person[] findPerson(Department department)
public Person[] findPerson(Mobile mobile)
public Person[] findPerson(Mobile mobile, Address address)
public Person[] findPerson(Address address, Department department)
public Person[] findPerson(DOB dob, Department, department)
public Person[] findPerson(Address address, DOB dob)

Now as David pointed out in his answer, we all know how to get String value of integer; probably we have read it somewhere.

static String.valueOf(new Integer(1));

But do you know how many more methods are there that are overloaded with the same name?

static String.valueOf(boolean b)
static String.valueOf(char c)
static String.valueOf(char[] data)
static String.valueOf(double d)
static String.valueOf(float f)
static String.valueOf(int i)
static String.valueOf(long l)
static String.valueOf(Object obj)

The benefits are that you don't have to memorize them all. You don't even have to guess because it's the same name all the way.

---

EDIT as per Namnodorel's advice

Consider this overloaded method of PrintStream class.

void println()
void println(boolean x)
void println(char x)
void println(char[] x)
void println(double x)
void println(float x)
void println(int x)
void println(long x)
void println(Object x)
void println(String x)

Just think about the readability if we had to write:

void println_emptyLine()
void println_boolean(boolean x)
void println_character(char x)
void println_characterArray(char[] x)
void println_double(double x)
void println_float(float x)
void println_integer(int x)
void println_long(long x)
void println_object(Object x)
void println_string(String x)

Answer 2

Overloading is useful when you make methods that do the same thing with values of different type.

Math class provides a perfect example - it has groups of function overload by type - four abs, four min, four max, and so on:

int max(int a, int b) {...}
float max(float a, float b) {...}
long max(long a, long b) {...}
double max(double a, double b) {...}

An alternative without overloading would force you to "encode" the type into the name of your method, e.g. Math.intMax(a, b) which would be detrimental to readability of user's code.

Answer 3

To be simple and concise: Overloading is just a possibility provided by Java (but most of modern and flexible languages use it) (and other languages such as C++ or C#) to allow developers to create for a same method/function name, several of it.

Why ?
Because method naming is important and method naming should convey the behavior of it. So, if two methods have the same behavior (Converting to a String for example) but than one uses a long as input and than the other uses a int as input, why having a different method name ?

    String myString = String.valueOf(new Integer(1));
    String myOtherString = String.valueOf(new Long(2));

The intention and the goal are the same, just the input parameters change.

When overloading is meaningful, you should use it instead of creating some variant clumsy names.

Answer 4

Method overloading is useful in the following scenario:

Consider you have a class that keeps track of a list of names. You have the style of code above, where each method has its own take on performing operations on this list of names.

Suddenly, the internal representation of the list changes (maybe from an array to an ArrayList, it doesn't really matter). Do you want to be the one responsible for refactoring every. single. method?

Method overloading is useful because then you can route all of the operations through a single, generic method. This means that whenever an internal representation changes, you only have to change that generic method, and all your other specialized methods still work the same.

---

Also, consider your provided example. What happens if you want to change how the program prints the message? You'll have to modify both methods to print the same type of message, a maintenance nightmare. Sure, it seems small now, but think about when your project grows, and you start to have many more methods relying on this (effectively fixed) message format.

Answer 5

I'm an object and I have a capability, the capability is fixed but can accept various parameters.

If the capability can accept 1000 kinds of parameters, do you want to rack your brains to think about 1000 capability names?

Take others post as a good practice of overload and take what JNIEnv do as a bad practice cause C doesn't support overloading.

CallStaticObjectMethod,
CallStaticObjectMethodV,
CallStaticObjectMethodA,
CallStaticBooleanMethod,
CallStaticBooleanMethodV,
CallStaticBooleanMethodA,
CallStaticByteMethod,
CallStaticByteMethodV,
CallStaticByteMethodA,
CallStaticCharMethod,
CallStaticCharMethodV,
CallStaticCharMethodA,
CallStaticShortMethod,
CallStaticShortMethodV,
CallStaticShortMethodA,
CallStaticIntMethod,
CallStaticIntMethodV,
CallStaticIntMethodA,
CallStaticLongMethod,
CallStaticLongMethodV,
CallStaticLongMethodA,
CallStaticFloatMethod,
CallStaticFloatMethodV,
CallStaticFloatMethodA,
CallStaticDoubleMethod,
CallStaticDoubleMethodV,
CallStaticDoubleMethodA,
CallStaticVoidMethod,
CallStaticVoidMethodV,
CallStaticVoidMethodA,

Reger to JNI for more detailed struct definition

Answer 6

Another reason to overload is to provide one or more default arguments.

Consider the following:

class Something {
    // Imagine that this is a real class, that does real work.

    public void doSomething(boolean b, char c, double d, int i) {
        // Imagine that this is one of the main components of class Something.
        System.out.println("Hi. You passed: " + b + ", " + c + ", " + d + ", and " + i + ".");
    }

    public void doSomething(boolean b, char c, double d) {
        doSomething(b, c, d, 42);
    }

    public void doSomething(boolean b, char c) {
        doSomething(b, c, 1.3579);
    }

    public void doSomething(boolean b) {
        doSomething(b, 'q');
    }

    public void doSomething() {
        doSomething(true);
    }
}

In this example, each overload provides a default for one of the parameters, chaining them together until you get a full call to the version of doSomething() that actually does the work.

Something s = new Something();
Something t = new Something();
Something u = new Something();

// ...

s.doSomething(true, 'c', 2.9);
t.doSomething(false, 'z');
u.doSomething();

See here for an example.