Java Abstract Class Implementieren einer Schnittstelle mit Generics

Ich versuche eine abstrakte Klasse zu definieren, die Comparable implementiert. Wenn ich die Klasse mit folgender Definition definiere:

public abstract class MyClass implements Comparable <MyClass>

Unterklassen müssen implementiert werden compareTo(MyClass object). Stattdessen möchte ich, dass jede Unterklasse implementiert compareTo(SubClass object)wird und ein Objekt ihres eigenen Typs akzeptiert. Wenn ich versuche, die abstrakte Klasse mit etwas zu definieren wie:

public abstract class MyClass implements Comparable <? extends MyClass>

Es wird beanstandet, dass "ein Supertyp keinen Platzhalter angeben darf".

Gibt es eine Lösung?

Es ist meiner Meinung nach etwas zu ausführlich, funktioniert aber:

public abstract class MyClass<T extends MyClass<T>> implements Comparable<T> {

}

public class SubClass extends MyClass<SubClass> {

    @Override
    public int compareTo(SubClass o) {
        // TODO Auto-generated method stub
        return 0;
    }

}

Abgesehen von den mechanischen Schwierigkeiten, auf die Sie beim Deklarieren der Signaturen stoßen, macht das Ziel wenig Sinn. Sie versuchen, eine kovariante Vergleichsfunktion einzurichten, die die gesamte Idee der Einrichtung einer Schnittstelle, die abgeleitete Klassen anpassen können, zunichte macht.

Wenn Sie eine Unterklasse SubClassso definieren, dass ihre Instanzen nur mit anderen SubClassInstanzen verglichen werden können , wie wird dann SubClassder durch definierte Vertrag erfüllt MyClass? Denken Sie daran MyClass, dass es und alle daraus abgeleiteten Typen mit anderen MyClassInstanzen verglichen werden können . Sie versuchen , denn das ist nicht wahr zu machen SubClass, was bedeutet , dass SubClassnicht nicht erfüllt MyClassist Vertrag: Sie können nicht ersetzen , SubClassfür MyClass, weilSubClass 's Anforderungen strenger sind.

Dieses Problem konzentriert sich auf Kovarianz und Kontravarianz und darauf, wie sich Funktionssignaturen durch Typableitung ändern können. Sie können sich entspannen eine Anforderung auf ein Argument der Typ Annahme einer breiteren Typ als die Supertyp Unterschrift Anforderungen-und Sie können stärken eine Anforderung auf einem Rückgabetyp versprechende eine schmalere Typ zurückzukehren als die Supertyp Unterschrift. Jede dieser Freiheiten erlaubt immer noch eine perfekte Substitution des abgeleiteten Typs für den Supertyp; Ein Anrufer kann den Unterschied nicht erkennen, wenn er den abgeleiteten Typ über die Schnittstelle des Supertyps verwendet, aber ein Anrufer, der den abgeleiteten Typ konkret verwendet, kann diese Freiheiten nutzen.

Willis Antwort lehrt etwas über generische Deklarationen, aber ich fordere Sie auf, Ihr Ziel zu überdenken, bevor Sie die Technik auf Kosten der Semantik akzeptieren.

siehe Javas eigenes Beispiel:

public abstract class Enum<E extends Enum<E>> implements Comparable<E>
    public final int compareTo(E o)

zu sehs kommentar: normalerweise ist das argument richtig. Generika machen jedoch Typbeziehungen komplizierter. Eine Unterklasse ist möglicherweise kein Subtyp von MyClass in Willis Lösung.

SubClassAist ein Subtyp von MyClass<SubClassA>, aber kein Subtyp vonMyClass<SubClassB>

Typ MyClass<X>definiert einen Vertrag, für compareTo(X)den alle seine Untertypen eingehalten werden müssen. Da gibt es kein Problem.

Ich bin mir nicht sicher, ob Sie die Erfassung benötigen:

Fügen Sie zunächst compareTo zur abstrakten Klasse hinzu ...

public abstract class MyClass implements Comparable <MyClass> {

@Override
public int compareTo(MyClass c) {
...
}    
}

Fügen Sie dann die Implementierungen hinzu ...

public class MyClass1 extends MyClass {
...
}

public class MyClass2 extends MyClass {
...
}

Wenn Sie compare aufrufen, wird die Super-Type-Methode aufgerufen ...

MyClass1 c1 = new MyClass1();
MyClass2 c2 = new MyClass2();

c1.compareTo(c2);

public abstract class MyClass<T> implements Comparable<T> {

}

public class SubClass extends MyClass<SubClass> {

    @Override
    public int compareTo(SubClass o) {
        // TODO Auto-generated method stub
        return 0;
    }

}

Eine andere Lösung gefunden:

1. Definieren Sie eine Schnittstelle für die Felder, aus denen sich das Comaprable zusammensetzt (z. B. ComparableFoo).
2. Implementieren Sie die Schnittstelle in der übergeordneten Klasse
3. Implementieren Sie Comparable für die übergeordnete Klasse.
4. Schreiben Sie Ihre Implementierung.

Die Lösung sollte folgendermaßen aussehen:

public abstract class MyClass implements ComparableFoo,Comparable<ComparableFoo> {
    public int compareTo(ComparableFoo o) {
    // your implementation
    }
}

Diese Lösung impliziert, dass möglicherweise mehr Dinge ComparableFoo implementieren - dies ist wahrscheinlich nicht der Fall, aber dann codieren Sie in eine Schnittstelle und der generische Ausdruck ist einfach.

Ich weiß, dass Sie gesagt haben, Sie möchten "compareTo (SubClass-Objekt), das ein Objekt seines eigenen Typs akzeptiert", aber ich schlage trotzdem vor, die abstrakte Klasse wie folgt zu deklarieren:

public abstract class MyClass implements Comparable <Object>

Führen Sie eine Überprüfung durch, wenn Sie compareTo in MySubClass überschreiben:

@Override
public int compareTo(Object o) {
    if (o instanceof MySubClass)) {
        ...
    }
    else throw new IllegalArgumentException(...)
}

ähnlich wie "gleich" oder "klonen"