Overloading

Oftentimes when writing classes in Java, we run into situations where a method provides useful functionality, but its implementation should change depending on the arguments sent to it. Java allows us to redefine a method with the same name but a different signature through overloading.

Overloading in Java is simple. For a method to be overloaded, the name of the method must be reused and a different set of parameters must be defined. The new set can be a different number of parameters, different types of parameters, or a mixture of both. Take the Log class below as an example:

 1: public class Logger {
 2: 
 3:     static void log(String message){
 4:         System.out.printf("[LOG] %s%n", message);
 5:     }
 6: 
 7:     static void log(String message, String level){
 8:         System.out.printf("[%s] %s%n", level, message);
 9:     }
10: 
11:     static void log(String message, String level, int lineNumber){
12:         System.out.printf("[%s] (line %d) %s%n", level, lineNumber, message);
13:     }
14: 
15:     static void log(Exception e){
16:         System.out.printf("[ERROR] %s: %s%n", e.getClass().getSimpleName(), e.getMessage());
17:     }
18: 
19:     public static void main(String[] args){
20:         log("Application started");
21:         log("Disk usage above 90%", "WARNING");
22:         log("Variable x is null", "ERROR", 42);
23:         log(new IllegalArgumentException("Invalid input supplied"));
24:     }
25: }

Lines 3, 7, 11, and 15 all declare a method named log. What varies between them are the parameters provided in the method declarations. The first declaration takes one String; the second takes two String​s; the third takes two String​s and an int; the fourth and final takes an Exception. The compiler "knows" which log to call based on the arguments provided in the method call. Line 20's call corresponds with Line 3's declaration, etc.

This is called ad hoc polymorphism.

Overloading occurs frequently within the Java standard library. This is often because Java programmers favour streamlined, aesthetically cohesive API's over distinctly named methods. For example, some believe it is easier to think about a single log method that changes based on argument context than a logSingleMessage, logMessageWithLevel, logMessageWithLineNumber, and logWithException.

1. The BankAccount class from earlier chapters currently requires both an owner name and an initial balance to be provided at construction time. Add a second constructor to BankAccount that takes only an owner name and defaults the balance to 0.0. Write a program that creates one account using each constructor and calls printBalance on both. What does this tell you about when overloading constructors is useful?

2. The chapter states that return type alone cannot distinguish two overloads. Attempt to compile the following class and record the error:

   public class InvalidOverload {
       static int compute(int x){
           return x * 2;
       }
       static double compute(int x){
           return x * 2.0;
       }
   }
   

   In your own words, explain why Java cannot use the return type to resolve which method to call. Hint: think about what happens when the return value is not assigned to a variable, as in System.out.println(compute(5)).

3. When the compiler must choose between two overloaded methods and an exact match is not available, it will use widening to find the closest compatible type. Write the following class, predict which overload will be called for each invocation, then compile and verify:

   public class Widening {
       static void print(int x){
           System.out.println("int: " + x);
       }
       static void print(double x){
           System.out.println("double: " + x);
       }
       public static void main(String[] args){
           print(42);       // which overload?
           print(3.14);     // which overload?
           print(42L);      // which overload? (long)
           print((byte) 5); // which overload? (byte)
       }
   }
   

   What general rule can you infer about how Java resolves overloads when no exact match exists?

4. Add a deposit overload to BankAccount that accepts an int in addition to the existing double version. Write a program that calls both overloads and verify the results are identical. Then consider: is this a good use of overloading, or would a single double method suffice? What are the tradeoffs?
5. The chapter mentions that the String class has 13 constructors. Compile and run the AllStringConstructors program from the chapter. Then identify which constructors produce identical output despite having different signatures (e.g. constructors 8, 9, 10, and 11 all print Java). Explain why different constructors can produce the same result, and why Java still provides all of them as separate overloads rather than collapsing them into one.