Interesting but strange behavior

Question

Somebody in this forum posted the following code
class A {
  public void show(A a) {
    System.out.print("A.show(A);\t");
class B extends A{
  public void show(A a) {
    System.out.print("B.show(A);\t");
  public void show(B a) {
    System.out.print("B.show(B);\t");
public class ABTest {
  public static void main(String[] args) {
    A a = new A();
    B b = new B();
    A bAsA = new B();
       a.show(a);    a.show(b);    a.show(bAsA); System.out.println();
       b.show(a);    b.show(b);    b.show(bAsA); System.out.println();
    bAsA.show(a); bAsA.show(b); bAsA.show(bAsA); System.out.println();
}The output was
A.show(A); A.show(A); A.show(A);
B.show(A); B.show(B); B.show(A);
B.show(A); B.show(A); B.show(A);
All this made perfect sense except for the output of
bAsA.show(b) which was B.show(A);
This is perplexing for me as the parameter being passed i.e., b is of type B then why this output. Any real explanation would be very welcome.

Answer 1

I thought the person in the other forum answered this pretty well but I will try it from another angle.
Method overloading is actually nothing more than a fancy way of naming a method. The resolution to which method will be called is done at compile time exactly as if the overloaded methods were named differently.
If your example was re-written as follows:
class A {
    public void showOne(A a) {
        System.out.print("A.showOne(A);\t");
class B extends A{
    public void showOne(A a) {
        System.out.print("B.showOne(A);\t");
    public void showTwo(B a) {
        System.out.print("B.showTwo(B);\t");
B b = new B();
A bAsA = new B(b);
bAsA.showOne(b);You would expect the output to be
B.showOne(A)
This is because the compiler resolved the method call to be showOne of class A. The compiler can only look at the reference type not the actual runtime type (since it does not exist yet).
When the call is performed at runtime, the JVM knows to call the method from the actual instance which has overrided the showOne method. You would not expect the JVM to call the showTwo method because the names are different.
When you overload a method, the actual name (signature) of the method includes the parameters exactly as if you had a "named" it differently.
Somehow I think I could have said this clearer but maybe it will help anyway.