Ich frage mich, ob es jemals einen gültigen Anwendungsfall für Folgendes gibt:

class Base {}

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

Es scheint ein gemeinsames Muster zu sein (siehe Sammlungen für eine Reihe von Beispielen), um eine Sammlung vom Typ @ zu akzeptierT, woT extends Comparable<? super T>.

Aber es scheint technisch unmöglich, den Vertrag von @ zu erfüllcompareTo() beim Vergleich mit einer Basisklasse, da nicht sichergestellt werden kann, dass eine andere Klasse die Basis nicht durch einen widersprüchlichen Vergleich erweitert. Betrachten Sie das folgende Beispiel:

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
    }
}

Wir haben zwei Klassen, die @ erweiteBase Vergleiche verwenden, die keiner gemeinsamen Regel folgen (wenn es eine gemeinsame Regel gäbe, würde sie mit ziemlicher Sicherheit in @ implementierBase). Die folgende fehlerhafte Sortierung wird jedoch kompiliert:

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

Wäre es nicht sicherer, nur @ zu akzeptierT extends Comparable<T>? Oder gibt es einen Anwendungsfall, der den Platzhalter validiert?