Type order with overloaded methods in Java

Question

Given two methods on the same class in Java :

public void doSomething( Person person );
public void doSomething( Employee employee );

where

Employee extends Person

If I call:

doSomething( employee )

I find that doSomething( Person ) gets invoked.

I'd have expected the overload with the closest matching contract be invoked, not with the most abstract (which is what I'm finding)

Could someone explain why?

Answer 1

The most specific applicable overload is used - but that overload is determined at compile -time, based on the compile time type of the employee variable.

In other words:

Employee employee = new Employee();
doSomething(employee); // Calls doSomething(Employee)

but:

Person employee = new Employee();
doSomething(employee); // Calls doSomething(Person)

Note that this is unlike overriding where it's the execution time type of the target object which is important.

Answer 2

How was employee declared? If it was declared as Person employee = new Employee(); , then doSomething(Person) is indeed the closest matching overload.

Unlike overrides, overloads are determined at compile time. Therefore, even though the runtime type of employee is Employee , the Person overload has already been chosen to be executed.

See the JLS §8.4.9 Overloading :

When a method is invoked (§15.12) , the number of actual arguments (and any explicit type arguments) and the compile-time types of the arguments are used, at compile time, to determine the signature of the method that will be invoked (§15.12.2) . If the method that is to be invoked is an instance method, the actual method to be invoked will be determined at run time, using dynamic method lookup (§15.12.4) .

Answer 3

On calling an overloaded, the method with the closest matching signature will be called. I suspect your employee is a Person variable. So at the method call, the reference type of employee causes your doSomething(Person person) to get selected.

Answer 4

The method selection is done at compile time not run time, so if you had

Person employee = new Employee();
doSomething(employee);

This would call doSomething(Person) as the declared type is Person, regardless of the fact the instance is also a Employee.