Generic Comparator problem

Question

Hi!
In our code we use Comparator, but can not make it work with generics.
The only way is to insert cast in some places, but that destroy the point in using generics in the first place.
Basically we have a superclass Foo and child classes FooA, FooB, FooC etc. (FooX extends Foo)
In Foo there is a method that needs to compare two FooX objects (they are always both of the same type).
So Foo declares an abstract method getComparator() and then calls compare() from it.
The current code is like this :
public abstract class Foo {
    public abstract Comparator<? extends Foo> getComparator();
    private int doAndCompare(Foo newFoo) {
        if (0 == this.getComparator().compare(this, newFoo)) {
         // some code ...
// each FooX is like this
public class FooA extends Foo {
    static Comparator<FooA> myComparator = new Comparator<FooA>() {
        public int compare(FooA one, FooA two) {
            // the computation is specific for each FooX
            return xxx; // compute and return some int value
    public Comparator<FooA> getComparator() {
        return  myComparator;
}This code has a compile error in the if statement:
The method compare(capture-of ? extends Foo, capture-of ? extends Foo) in the type Comparator<capture-of ? extends Foo> is not applicable for the arguments (Foo, Foo)
I could use "super" instead of "extends" in the getComparator() definition, but the each FooX would have an error, which are solvable only by casting.
Is there a cast-less solution ?

Answer 1

This might not be the post that will answer your question (since I honestly do not completely get your question), but might provide some (to) creative insights.
A weird construct that will work without casting (but probably not very useful):
public static void main(String[] args) {
     FooX x1 = new FooX();
     FooX x2 = new FooX();
     // requires a parameter of type FooX
     x1.doAndCompare(x2);
     FooY y1 = new FooY();
     FooY y2 = new FooY();
     // requires a parameter of type FooY
     y1.doAndCompare(y2);
     Foo f1 = new FooY();
     Foo f2 = new FooY();
     f1.doAndCompare(y2); // requires a parameter of type Foo, so no actual benifit here? Will work though
     f1.doAndCompare(x2); // Will throw a ClassCastException, so not very usable
static abstract class Foo<T extends Foo<?>> implements Comparable<T> {
     public void doAndCompare(T foo) {
          if (0 == this.compareTo(foo)) {
               // do your magic
static class FooX extends Foo<FooX> {
     public int compareTo(FooX o) {
          // TODO Auto-generated method stub
          return 0;
static class FooY extends Foo<FooY> {
     public int compareTo(FooY o) {
          // TODO Auto-generated method stub
          return 0;
}An example that works with casting and that will work:
public static void main(String[] args) {
     FooX x1 = new FooX();
     FooX x2 = new FooX();
     // requires a parameter of type Foo, FooX.compareTo(FooX) will be invoked
     x1.doAndCompare(x2);
     FooY y1 = new FooY();
     FooY y2 = new FooY();
     // requires a parameter of type Foo, FooY.compareTo(FooY) will be invoked
     y1.doAndCompare(y2);
     // requires a parameter of type Foo
     y1.doAndCompare(x2); // will work
static abstract class Foo implements Comparable<Foo> {
     public void doAndCompare(Foo foo) {
          if (0 == this.compareTo(foo)) {
               // do your magic
static class FooX extends Foo {
     public int compareTo(Foo foo) {
          if (foo instanceof FooX) {
               return this.compareTo((FooX) foo);
          } else {
               return 1; // return what's apropriate of not equal
     public int compareTo(FooX fooX) {
          return 0;
static class FooY extends Foo {
     public int compareTo(Foo foo) {
          if (foo instanceof FooY) {
               return this.compareTo((FooY) foo);
          } else {
               return 1; // return what's apropriate of not equal
     public int compareTo(FooY fooY) {
          return 0;
}I couldn't help noticing that in your original post you very specifically used 'if comparision == 0'. That looks a lot like Foo.equals() to me. Isn't that just what you want?