如何为接口的所有实现实现compareTo？

Question

In Java, what is the best approach to provide natural ordering for all implementations of an interface?

I have an interface, for which I want to ensure/provide natural ordering between all implementations by extending the Comparable interface:

public interface MyInterface extends Comparable<MyInterface> {

}

There will be several implementations of this interface, each of which can define a natural ordering for its own instances, but which may not know how to order itself against other implementations.

One approach, which I have used, is to introduce recursive generics and split the natural order comparison by implementation and by instance:

public interface MyInterface<X extends MyInterface<X>> extends Comparable<MyInterface> {

  @Override
  default int compareTo(MyInterface o) {
    // the interface defines how to compare between implementations, say...
    int comp = this.getClass().getSimpleName().compareTo(o.getClass().getSimpleName());
    if (comp == 0) {
      // but delegates to compare between instances of the same implementation
      comp = compare((X) o);
    }
    return comp;
  }

  int compare(X other);
}

This means that the implementations of MyInterface only have to compare between their own instances:

public class MyClass implements MyInterface<MyClass> {

  public int compare(MyClass other) {
    return 0; // ... or something more useful... 
  }
}

But, recursive generics can become very difficult to maintain.

Is there a better way?

Answer 1

You could move this casting compare((X) o); from interface's default method to the implementations and therefore you don't need generic <X extends MyInterface<X>> at all.

public interface MyInterface extends Comparable<MyInterface> {
    @Override
    default int compareTo(MyInterface o) {
        ...
        comp = compare(o);
        ...
    }
    int compare(MyInterface other);
}

In this case implementations could look like:

public class MyClass implements MyInterface {
    private Integer property;
    public int compare(MyInterface other) {
        return Integer.compare(this.property, ((MyClass) other).property);
    }
}

Answer 2

So, this is the best I have come up with so far, which kind of blends my original approach with Ruslan's answer and tries to manage the trade offs:

We define the interface without recursive generics:

public interface MyInterface extends Comparable<MyInterface> {

  @Override // as per the Comparable interface (not needed, but included here for clarity)
  int compareTo(MyInterface o);
}

Then we create an abstract class that defines the comparison between implementations, and delegates to the implementations to compare between instances of that implementation. This improves on having this functionality in the interface, as we limit the scope of the compare() method to protected .

public abstract class MyAbstractClass implements MyInterface {

  @Override
  public int compareTo(MyInterface o) {
    // the interface defines how to compare between implementations, say...
    int comp = this.getClass().getSimpleName().compareTo(o.getClass().getSimpleName());
    if (comp == 0) {
      // but delegates to compare between instances of the same implementation
      comp = compare(o);
    }
    return comp;
  }

  protected abstract int compare(MyInterface other);
}

Then in each implementation, we check/cast to that implementation. This should never be called with an implementation other than itself, but just to be safe, we throw an IllegalArgumentException if that were to happen.

public class MyClass implements MyInterface {

  public int compare(MyClass o) {
    if (o instanceof MyClass) {
      return 0; // ... or something more useful... 
    } else {
      throw new IllegalArgumentException("Cannot compare " + this.getClass() + " with " + o.getClass());
    }
  }
}