Generic method not overriding similar generic method in superclass -> Which one is used?

Question

Given this situation:

 public class Animal {

    public <T> void genericMethod(T t){
        System.out.println("Inside generic method on animal with parameter " + t.toString());
    }
}

public class Cat extends Animal {

    public <T extends Cat> void genericMethod(T t){
        System.out.println("Inside generic method on cat with parameter " + t.toString());
    }
}

public class Main {

    public static void main(String[] args) {
        Animal animal = new Animal();
        Cat cat = new Cat();
        cat.genericMethod(cat);
    }
}

The method genericMethod() in class Cat is definitely NOT overriding the superclass method (and the compiler complains if I add @Override signature) which is reasonable, as the requirements to the type T are different.

But I do not quite understand, how the compiler decides which of the two methods to use in the call cat.genericMethod(cat) in the main method. Because actually both methods are visible and both are applicable. I would have expected a compiler error like "ambigous function call" here. Can someone explain this behavior?

Answer 1

These two methods have a different erasure due to the generic type bound of the sub-class method.

For the super class method the erasure is:

public void genericMethod(Object t)

For the sub class method the erasure is:

public void genericMethod(Cat t)

Method overloading resolution rules choose the method with the best matching arguments. Therefore when you pass a Cat argument, the second (sub-class) method is chosen.

Answer 2

Java, at compile time, will choose the most specific matching method. In your example, this means the Cat implementation of the method.

THere are two things to notice:

• If you pass to it an Animal, it is obvious that only the method declared in Animal will be used (since it doesn't match the T extends Cat constraint).

• If you pass to it a Cat:

  1. Java decides that the two methods match (because of the Cat parameter)
  2. Because of the aforementioned rule, Java simply take the most specific one (it does not care anymore about the fact that the parameter is a Cat).