Method Overloading

Hello students, welcome to Kwickprep. Can two methods in one class have exactly the same name? In Java, yes they can. Today we will learn method overloading, how Java picks the right version, how it differs from overriding, and two exam programs.

Method overloading means writing several methods with the same name. They are all in the same class. But their parameter lists must be different. They can differ in the number of parameters, their types, or their order. Changing only the return type is not enough, and gives a compile error. Polymorphism means one name with many forms, and overloading is compile time polymorphism.

Here are two methods named area. The first takes one side, for a square. The second takes length and width, for a rectangle. The call area of four has one argument. So Java runs the square version, and prints sixteen.

Let us test some pairs, a favourite exam question. One int against two ints is valid, because the number differs. Int against double is valid, because the type differs. Int then double, against double then int, is valid, because the order differs. Only a different return type is an error. Only different parameter names is also an error, because names do not count.

The compiler is the tool that turns your code into a program, and it chooses the version before the program runs. First, it looks for an exact match of the argument types. If there is none, it tries widening, which means moving to a bigger type, like int to long or double. Next, it tries boxing, which wraps an int into an Integer object. If nothing fits, or two versions fit equally well, you get a compile error.

Pause and predict. There is no calc that takes an int. The call is calc of five, and five is an int. Which version runs? Both long and double can hold an int. Java picks the closest widening, which is long. So it prints long.

Now a trap. Here the call is calc of two and three, and both are ints. The first version needs only the second value widened. The second version needs only the first value widened. Neither is better, so the compiler reports that the reference to calc is ambiguous.

Students often mix up overloading with overriding. Inheritance means a child class receives the members of a parent class. Overriding happens when the child class writes its own version of a parent method. The name and the parameter list must be exactly the same. Java decides which version to run while the program is running, based on the actual object.

Here Pet is the parent class, and Dog extends Pet, so Dog is the child. Both have a method called sound with no parameters. The variable pet is of type Pet, but the object is a Dog. At run time Java uses the Dog version. So it prints Woof, not Hmm.

Here is the comparison exams ask for. Overloading happens in the same class, while overriding needs a parent and a child class. In overloading the parameters must differ, but in overriding they must be the same. Overloading is decided at compile time, and overriding at run time. So inheritance is not needed for overloading, but it is needed for overriding. That is why they are called compile time and run time polymorphism.

Now two exam style programs. First, overload vol, short for volume. The version with one side finds the volume of a cube, side times side times side. The version with three values finds the volume of a cuboid, length times breadth times height. Vol of three prints twenty seven. Vol of two, three and four prints twenty four.

Second, a program where the argument type decides. One show takes an int, and the other takes a char, a single character. Pause and predict the output first. A in single quotes is a char, so it matches the char version exactly. It prints char A. Sixty five is an int, so it prints int sixty five. Java never widens when an exact match exists.

Here are four tips for overloading questions. Write each version with a clear, different parameter list. In main, call every version at least once, so the examiner sees each one work. When predicting output, match the argument types first, then think about widening. And never try to overload by changing only the return type.

Let us revise what we learned today. Overloading means the same name with different parameter lists. The compiler tries an exact match, then widening, then boxing. If two versions fit equally, the call is ambiguous. Overriding means a child class rewrites a method with the same signature. Overloading is decided at compile time, and overriding at run time.