why method overriding does not check method signature when using generics?

for example, we know that the following is not allowed because overriding need the same method signature.

class Parent{
  void f(Parent p){}
}

class Son extends Parent{
 @Override//not allowed ,change the signature
 void f(Son s){} 
}

However, if we use generics, like

class Parent<T extends Parent>{
  void f(T p){}
}

class Son extends Parent<Son>{
 @Override//ok 
 void f(Son s){} 
}

then it is allowed , but why?

f(Parent p) and void f(Son s) are different methods, having different signatures. Since they have the same name, if is referred to as overloading.

Generics is the compiler playing tricks with the JVM. When you define Parent<T extends Parent> and f(T p), the compiler will be able to pretend that T can be any sub-type of Parent, depending on the type argument specified for T when Parent is referenced.

To the JVM, the method is still created as f(Parent p), since that is the bound for T. This is what type erasure is about.

When you then declare Son extends Parent<Son>, the compiler pretends that f(T p) was declared as f(Son p), which would make f(Son s) method of class Son an override of the f method in Parent. However, that is just the compiler pretending, the JVM only sees method f(Parent p) in the super-type, so the f in Son is not an override of the f method in Parent.

To implement the pretended view of the world that generics has added to the Java language, the compiler solves the discrepancy by creating a bridge method. The result is that, after type-erasure, the runtime code seen by the JVM will be:

class Parent {
    void f(Parent p) {}
}

class Son extends Parent {
    @Override
    bridge synthetic void f(Parent p) {
        this.f((Son) p);
    }

    void f(Son s) {}
}

bridge and synthetic are of course not keywords you can use in Java source code, but they are internal modifiers specified on the method in the bytecode.

As you can see, if someone has a Parent<Son> parent = new Son(); variable and calls parent.f(son), the hidden bridge method will redirect the call to the f(Son s) method.

It is all the compiler playing tricks to fit the Java language into the bytecode that the JVM executes.

The conditions for Overloading :

1.Both must have the same method name.

2.Both must have different argument lists.

3.Have different return types.

4.Have different access modifiers.

5.Throw different checked or unchecked exceptions.

Your Second code Fails to meet condition number 2.

T is a type. <T extends Parent> means anything that is of type Parent or its subclass is acceptable. ie, Son(Subclass) or Parent(Parent)

So, Due to Same Argument lists. It is considered as Overriding.