Implementing two generic interfaces

Question

I have a generic interface,
public interface Callback<R> {
   void result(R r);
}Now I want to implement two Callback interfaces, like this
class X implements Callback<Type1>, Callback<Type2> {
   public void result(Type1 r) {};
   public void result(Type2 r) {};
}But Eclipse tells me "The interface Callback cannot be implemented more than once with different arguments".
I don't see the reason why really. The two overloaded result methods have different signatures so there shouldn't be any problem in resolving the correct one based on parameter type in principle.
Does anybody know the reason for this restriction or is it maybe an issue with Eclipse. I'm using Eclipse 3.2M5a and Java 6.0 beta.

Answer 1

mlk has the correct answer, but here's some more explanation:
Generics are only used at compile time. The actual bytecode specifies the base object type (aka type erasure), in this case Object. When you implement a generified interface, the compiler will generate a bridge method from the erased type to the specific type.
Some examples should make this clearer.
First, your interface. If you run javap on the compiled class, you'll see that it only defines a single method, "void result(Object)".
Code that invokes the interface, like this:
    Callback<String> foo = \\
    foo.result("bar");also gets translated to a call on the base type. As far as the compiled class is concerned, there is no type safety. However, the compiler will complain if you pass something other than a String.
The implementation class is where things get interesting:
public class TestCallback implements Callback<String> {
  public void result(String x) {
}If you run javap on this class, you'll see that it contains two implementations of result(): one that takes a String, and one that takes an Object. If you look at the bytecode, the latter performs a cast on the Object and invokes the String variant.