Me pregunto si alguna vez hay un caso de uso válido para lo siguiente:

class Base {}

class A implements Comparable<Base> {
    //...
}

Parece ser un patrón común (verColecciones para varios ejemplos) para aceptar una colección de tiposT, dóndeT extends Comparable<? super T>.

Pero parece técnicamente imposible cumplir el contrato decompareTo() cuando se compara con una clase base, porque no hay forma de garantizar que otra clase no extienda la base con una comparación contradictoria. Considere el siguiente ejemplo:

class Base {
    final int foo;
    Base(int foo) {
        this.foo = foo;
    }
}

class A extends Base implements Comparable<Base> {
    A(int foo) {
        super(foo);
    }
    public int compareTo(Base that) {
        return Integer.compare(this.foo, that.foo); // sort by foo ascending
    }
}

class B extends Base implements Comparable<Base> {
    B(int foo) {
        super(foo);
    }
    public int compareTo(Base that) {
        return -Integer.compare(this.foo, that.foo); // sort by foo descending
    }
}

Tenemos dos clases extendidasBase utilizando comparaciones que no siguen una regla común (si hubiera una regla común, casi con seguridad se implementaría enBase) Sin embargo, se compilará el siguiente tipo roto:

Collections.sort(Arrays.asList(new A(0), new B(1)));

¿No sería más seguro aceptar soloT extends Comparable<T>? ¿O hay algún caso de uso que valide el comodín?