Generic Method override compatibility

Question

I tried to find references to the problem but couldn't. I face it all the time and I thought some else must have had the same problem already.
Oh well, here it goes.
With both 3.1M4 and 3.1M5a the following code compiles without any problems.
public interface MyIface {
    public <T> void foo(T p);
public class MyClass implements MyIface{
    public <T extends Integer> void foo(T p) {
         //does something
}However, javac 1.5 gives me:
MyClass.java:1: MyClass is not abstract and does not override abstract method <T>foo(T) in MyIface
public class MyClass implements MyIface{
^
1 error
I found many different variations to this problem, which I am not going to list here as I am trying to be concise. But for the eclipse compiler, <T extends Integer> is the same as <T> in terms of method signature. For the javac compiler these are different thingss.
Does anyone know if this is a Bug in eclipse or javac, or if this is a known decision, which is taking both tools in different directions?
Coconha

Answer 1

Coco, you have to understand how generics work in the compiler to understand this. Basically, erasure means that all the fancy generics stuff you write in your source code gets 'erased' when it gets compiled... So:public interface MyIface {
    public <T> void foo(T p);
}gets compiled and the resulting .class file, if you decompiled it, would actually look like this:public interface MyIface {
    public void foo(Object p); // NOTICE that "T" gets erased to plain old java.lang.Object
}See? The same thing happens with MyClass:public class MyClass implements MyIface {
    public <T extends Integer> void foo(T p) {
         //does something
}after it's compiled, actually looks like this inside the .class file:public class MyClass implements MyIface {
    public void foo(Integer p) { // NOTICE that "T extends Integer" gets erased to plain old Integer!
         //does something
}Do you see what the problem is now? MyClass has a method called foo(Integer) and MyIface has a method called foo(Object). Obviously now, you see, foo(Integer) shouldn't override foo(Object). The Eclipse compiler should actually complain that you haven't implemented foo(Object) in MyClass. Do you follow?
Let's look at your second example.public class Base {
  public <S> void foo(S a) {
    System.out.println("Base: " + a);
public class Sub extends Base {
  public <S extends Integer> void foo(S a) {
    super.foo(a); // should be an error here! super.foo(Integer) doesn't exist!
    System.out.println("Sub: " + a);
}Let's apply erasure manually and see why there is no error:public class Base {
  public void foo(Object a) {
    System.out.println("Base: " + a);
public class Sub extends Base {
  public void foo(Integer a) {
    super.foo(a); // calls foo(Object a)! you could also write "this.foo((Object)a)"
    System.out.println("Sub: " + a);
}Sub actually has two methods - foo(Integer a) which it defines explicitly - and foo(Object a) which it inherits from Base.