Why is the super class method called?

Question

class One { 
  public void doThing(One o) {System.out.println("One");}
}

class Two extends One{
  public void doThing(Two t) {System.out.println("Two");}
}

public class Ugly {
  public static void main(String[] args) {
    Two t = new Two();
    One o = t;
    o.doThing(new Two());
  }
}

Result : One

class One { 
  public void doThing(One o) {System.out.println("One");}
}

class Two extends One{
  public void doThing(Two t) {System.out.println("Two");}
}

public class Ugly {
  public static void main(String[] args) {
    Two t = new Two();
    One o = t;
    t.doThing(new Two());
  }
}

Result : Two

I know that at runtime, even though the object reference is of the super class type, the actual object type will be known and the actual object's method will be called. But if that is the case, then on runtime the doThing(Two t) method should be called but instead the super class method doThing(One o) is called. I would be glad if somebody explained it

In the second piece of code it prints "Two".

Question : when calling from the super class reference it is calling the doThing(One o) when calling from the sub class reference it is calling the doThing(Two o)

NOTE: I know that i am over loading and not over riding. i have edited my question for better clarity.

Answer 1

The method doThing() have different method signature in One and Two.

One.doThing(One one)
Two.doThing(Two two)

Since, the signature isn't matched, Two.doThing(Two) doesn't Override One.doThing(One) and since o is of type One, One.doThing() is called.

Also to be noted that One.doThing(One) can take instance of Two as an argument for One.doThing(One) as Two extends One.

Basically, "@nachokk - You are Overloading, not Overriding"

In first scenario, when you did

Two t = new Two();
One o = t;
o.doThing(new Two());

So, o is an instance of One and Two.doThing(Two) isn't available to o thus calls One.doThing(One)

In second scenario,

Two t = new Two();
One o = t;
t.doThing(new Two());

t is an instance of Two and thus Two.doThing(Two) is called.

Answer 2

The excelent book SCJP for Java 6 states:

If a method is overridden but you use a polymorphic (supertype) reference to refer to the subtype object with the overriding method, the compiler assumes you’re calling the supertype version of the method.

So basically with using supertype for reference you're telling compiler to use supertype method.