Choosing More Specific Overloaded Methods Problem

[Micheal John]

class GFC211 {}  
class GFC212 extends GFC211 {}
class GFC213 extends GFC212 {
  static void m(GFC211 x, GFC211 y) {System.out.print("GFC211,GFC211");}
  static void m(GFC211 x, GFC212 y) {System.out.print("GFC211,GFC212");}
  static void m(GFC212 x, GFC211 y) {System.out.print("GFC212,GFC211");}
  static void m(GFC212 x, GFC212 y) {System.out.print("GFC212,GFC212");}
  static void m(GFC211 x, GFC213 y) {System.out.print("GFC211,GFC213");}
  public static void main(String[] args) {
    GFC213 gfc213 = new GFC213(); m(gfc213, gfc213);
}}

For the above coding why it is compile time error? I thought of GFC212,GFC212 as output, since it is more specific..

Can anyone explain why it is compile error?

[Joe San]

It is obvious that the compiler will get confused when it sees such a code. The rule the compiler follows for most specific method is that,

Consider the following case,

myMethod(long kk, int ii)
myMethod(int aa, int pp)

Now considering the above code, the compiler knows that when you invoke myMethod(4L, 5), it knows that only one method that takes a long as argument works and without any ambiguity she calls the one that takes long as arg.

So, if you corelate the above small example with the one you have provided, when you invoke a method with a subclass object, there are many versions that the compiler can invole and if you invoke the same with a superclass object, there are again many versions that the compiler can try and invoke which is why it gets confused and splits out a compile time error.

Anyone to elaborate more on this?

[John Johnson]

It would be much better if you could give better names to your classes.

[Keith Lynn]

Notice that if you remove all but the last two methods, you still have a compile-time error.

class GFC211 {}  
class GFC212 extends GFC211 {}
class GFC213 extends GFC212 {
//  static void m(GFC211 x, GFC211 y) {System.out.print("GFC211,GFC211");}
//  static void m(GFC211 x, GFC212 y) {System.out.print("GFC211,GFC212");}
//  static void m(GFC212 x, GFC211 y) {System.out.print("GFC212,GFC211");}
  static void m(GFC212 x, GFC212 y) {System.out.print("GFC212,GFC212");}
  static void m(GFC211 x, GFC213 y) {System.out.print("GFC211,GFC213");}
  public static void main(String[] args) {
    GFC213 gfc213 = new GFC213(); m(gfc213, gfc213);
}}

C:\TEMP>javac GFC213.java
GFC213.java:10: reference to m is ambiguous, both method m(GFC212,GFC212) in GFC
213 and method m(GFC211,GFC213) in GFC213 match
    GFC213 gfc213 = new GFC213(); m(gfc213, gfc213);
                                  ^
1 error

According the JLS, the intuition is that one method is more specific than another if any invocation of it could be sent the other method without a compile-time error.

In this case, notice that there are parameters that you could send to one of these methods that could not be passed to the other.

Consider these pairs.

new GFC211(),new GFC213()
 
new GFC212(),new GFC212()

The first pair would be accepted by the second method (GFC211,GFC213), but it would not be accepted by (GFC212,GFC212) since a GFC211 is not a GFC212.

The second pair would be accepted by the first method (GFC212,GFC212), but it would not be accepted by (GFC211,GFC213) since a GFC212 is not a GFC213.