如何使接口扩展与通用参数兼容？

Question

Follow up to this question , but I'll try to make it self-contained.

Suppose I have an interface called Animal , which for various reasons has a generic type parameter representing the implementing class:

public interface Animal<A extends Animal<A>>

I also have a sub-interface, Dinosaur , which behaves in the same way:

public interface Dinosaur<D extends Dinosaur<D>> extends Animal<D>

Now I have a class Lizard which implements Animal :

public class Lizard implements Animal<Lizard>

and a subclass, Trex , which implements Dinosaur :

public class Trex extends Lizard implements Dinosaur<Trex>

These four declarations now produce an error. This is because the class Trex implements the interface Animal twice, but with different type parameters: since it extends Lizard , it implements the interface Animal<Lizard> , and since it implements Dinosaur<Trex> , it implements Animal<Trex> .

Animal<Trex> is not a subinterface of Animal<Lizard> , even though Trex is a subclass of Lizard , so we get a compiler error.

I'm sure there's some way around this using wildcards, but I can't work out what it is.

Here's something you can compile to get the same error:

public class InterfaceTest
{
  private interface Animal<A extends Animal<A>> {}

  private interface Dinosaur<D extends Dinosaur<D>> extends Animal<D> {}

  private class Lizard implements Animal<Lizard> {}

  private class Trex extends Lizard implements Dinosaur<Trex> {}
}

Answer 1

This is because the class Trex implements the interface Animal twice, but with different type parameters

Yup, this is the case, and there's no way around this directly - it's a technical limitation because generics are implemented using erasure. You can never implement the same interface on more than one class with different generic parameters. When the generic types are erased you'd end up with it extending two interfaces identically, with no way to distinguish between methods making use of those different generic types, and thus no way for the runtime to determine which method to execute.

For your particular use case there's probably a workaround that means you don't have to implement the same interface with different type parameters, but without more details it's impossible to say what that might be.

EDIT: Looking at the linked question, it looks like you could solve this problem by using the other answer (the one you haven't accepted) that specifies the return value in this way rather than declaring it on the class:

public <T extends JNumber> T add(T addend);

This should then mean you don't need to declare the generic type parameter on your classes and interfaces, and then thus shouldn't have this issue.