Covariant return types over Generic return types.

Question

Feeling rather slow on the uptake having only just discovered covariant return types (thanks again cowwoc), I've been looking over one of our soon to be released APIs and think using covariants makes muchos sense for it but there's one issue:
public interface Foo {
     Foo get();
public interface Bar {
     Bar get();
public interface FooBar
          extends Foo, Bar {
     FooBar get();
}Which isn't allowed, as the compiler states the return types are incompatible (I think incorrectly as it's been further overridden). Its generic equivalent is:
public interface FooX<T> {
     T get();
public interface BarX<T> {
     T get();
public interface FooBarX
          extends FooX<FooBarX>, BarX<FooBarX> {
     FooBarX get();
}Which works, and well, but the extra hassle of declaring/using generics is turning out to be a pain for our users (this pattern is used extensively). Does anyone have any simple suggestions/recommendations to resolve either the covariant issue or simplify the generics one? Also does anyone have any preferences to which one they prefer (and why)?
Incidentally does anyone know the the rationale behind not allowing the first example, when clearly it can't be abused (can it)?

Answer 1

BobDavies wrote:
. it is because you can not override a method or its definition with the same signatur, which does not include return type.What do you mean "does not include return type"?
method signature does not count the return type. i think java does allow you to repeat definitions in a sub class but when you put up a different retyrn type, it sees it as an attempt to do overriding, so it flags it out.
the fact that it works is becuase you are not extending anything but itsself:I am aware of the reasons for the Generic version working, it achieves our aim, I just don't like it when in use. And was wondering why the joining covariants do not work. I still can't see the reason for the FooBar not being allowed when you are allowed to return subtypes. You cannot break the inheritance/return types expectations like this can you? E.g. if I write a bit of code using Foo, it will still work with FooBar, and the same with Bar using FooBar, no? Can you show me an example of why this isn't allowed?your generic version should NOT work either; it is working becuase you are confused:
public interface FooBarX extends FooX<FooBarX>, BarX<FooBarX> only equals to
public interface FooBarX extends FooBarX, FooBarX