Theory：Overloading

The overloading mechanism allows us to not write different names for methods that perform similar operations.

提示

Important that it's impossible to declare more than one method with the same name and parameters (number and types), even with different return types. The return type is not considered for overloading because it's not a part of the signature.

Looking ahead, we'll assume that overloading is a form of the static (compile-time) polymorphism.

# Overloading and casting

To understand how overloading deals with type casting, let's consider an example of overloaded methods that only differ in the type of the single argument and see when each of them will be invoked and why.

public class OverloadingExample {

    public static void print(short a) {
        System.out.println("short arg: " + a);
    }

    public static void print(int a) {
        System.out.println("int arg: " + a);
    }

    public static void print(long a) {
        System.out.println("long arg: " + a);
    }

    public static void print(double a) {
        System.out.println("double arg: " + a);
    }

    public static void main(String[] args) {
        print(100);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Now if we call print(100), the program outputs:

int arg: 100

What we see here is that 100 is treated as int and the corresponding method is invoked.

In the case where the type of a method parameter is not exactly the same as the type of the passed argument, the compiler chooses the method that has the closest type of the argument in order of the implicit casting.

Since all integer literals are treated as int by default, int will be the starting point. The closest one will then be long.

Let's remove or comment the method public static void print(int a), then recompile and run the program again. The result is as expected:

long arg: 100

Ok, now, let's remove the method public static void print(long a) too. Since we have no method with float argument, the next type in the order of implicit type casting will be double. After recompiling the program outputs:

double arg: 100.0

If we remove the method public static void print(double a) the only method we have left is the one with short type of argument. The program won't compile if we just call print(100) as we did before.

Let's explain why. When we pass some value to the method, the compiler does not evaluate it. All that is known is that it is integer literal and hence has integer type.

In our case, since 100 is treated as an int by default and JVM doesn't know if the passed value can be cast to short safely, the only way to pass short argument is by casting the value explicitly:

 public class OverloadingExample {

    public static void print(short a) {
        System.out.println("short arg: " + a);
    }

    public static void main(String[] args) {
        print((short) 100);  // explicit casting 
    }
}

1
2
3
4
5
6
7
8
9
10

# Conclusion

Method overloading allows you to implement two or more methods with the same name, but different arguments. The arguments of such methods may differ in their number or type. This helps to avoid having various method references for similar tasks. When invoked, the proper method is chosen based on the provided arguments. If the argument has a different type from what is expected, the closest type of the argument in order of the implicit casting is used.

编辑

#Java

上次更新: 2022/09/26, 16:55:15

← Theory：Paradigms Theory：Write, compile, and run→