Liebe Java-Profis, ich hänge zur Zeit an folgender aufgabe:
Ich muss eine Klasse implementieren, die das Heap-Sort-Verfahren realisiert, das dürfte nicht das Problem sein. Die eigentliche Schwierigkeit für mich ist, dass die Elemente des Baums den generischen Typ <T> haben und ich das Vergleichen der einzelnen Werte mithilfe der CompareTo-Methode durchführen muss.
In der Aufgabe steht:
Die Klasse soll einen generischen Parameter T besitzen, wobei sichergestellt sein muss, dass T das Interface Comparable implementiert.
Wie soll ich die Kopfzeile benennen?
public class HeapSort<T implements Comparable<T>> ?
Weitere Frage, wie kann ich die CompareTo Methode programmieren? Muss ich dazu java.util importieren oder kann ich die Werte direkt mit einer istGrößer-Abfrage vergleichen? , also z.B.
return getValue()>obj.getValue() ? 1
In der Aufgabe steht leider nicht so viel dazu.
Weitere Frage, wie kann ich die CompareTo Methode programmieren? Muss ich dazu java.util importieren oder kann ich die Werte direkt mit einer istGrößer-Abfrage vergleichen? , also z.B.
return getValue()>obj.getValue() ? 1
Die compareTo-Methode wird vom Interface Comparable (welches ja T implementieren muss) bereitgestellt.
Deine T's haben dann also eine compareTo()-Methode, die du auf ihnen aufrufen kannst.
Das ist ja gerade der ganze Sinn davon, dass deine T's Comparable implementieren sollen, weil sie nur so verglichen werden können.
Also, dein Sortieralgorithmus wird ja irgendwann zwei T's miteinander vergleichen wollen, und dann kannst du machen:
Java:
T t1 =...;T t2 =...;if(t1.compareTo(t2)<0){// t1 ist _echt_ kleiner als t2}
Die compareTo-Methode wird vom Interface Comparable (welches ja T implementieren muss) bereitgestellt.
Deine T's haben dann also eine compareTo()-Methode, die du auf ihnen aufrufen kannst.
Das ist ja gerade der ganze Sinn davon, dass deine T's Comparable implementieren sollen, weil sie nur so verglichen werden können.
Also, dein Sortieralgorithmus wird ja irgendwann zwei T's miteinander vergleichen wollen, und dann kannst du machen:
Java:
T t1 =...;T t2 =...;if(t1.compareTo(t2)<0){// t1 ist _echt_ kleiner als t2}
Die compareTo-Methode wird vom Interface Comparable (welches ja T implementieren muss) bereitgestellt.
Deine T's haben dann also eine compareTo()-Methode, die du auf ihnen aufrufen kannst.
Das ist ja gerade der ganze Sinn davon, dass deine T's Comparable implementieren sollen, weil sie nur so verglichen werden können.
Also, dein Sortieralgorithmus wird ja irgendwann zwei T's miteinander vergleichen wollen, und dann kannst du machen:
Java:
T t1 =...;T t2 =...;if(t1.compareTo(t2)<0){// t1 ist _echt_ kleiner als t2}
Sorry, glaube habe mich falsch ausgedrückt. Passiert die Vererbung automatisch, oder muss ich diese Klasse Comparable<T> ebenfalls ausprogrammieren? Hoffe, Du verstehst was ich meine.
Sorry, glaube habe mich falsch ausgedrückt. Passiert die Vererbung automatisch, oder muss ich diese Klasse Comparable<T> ebenfalls ausprogrammieren? Hoffe, Du verstehst was ich meine.
Ich verstehe nicht ganz was Du meinst. Ich habe jetzt die CompareTo-Methode folgendermaßen implementiert:
Code:
public <T> int CompareTo(int i, int j){
T t1 = knoten[i];
T t2 = knoten[j];
if (t1.CompareTo(t2)>0) {
return -1;
} else if (t1.CompareTo(t2)<0) {
return 1;
} else return 0;
}
HeapSort erwartet, dass Du einen Typ angibst, der Comparable implementiert.
HeapSort implementiert das CompareTo nicht! Und Deine Implementierung ist einfach nur Quatsch! Comparable<T> müsste eine Methode
int CompareTo(T o1, T o2);
implementieren.
Der Code, den Du da zeigst:
a) implementiert kein Compareable
b) Erzeigt einen eigenen Generic T - so der COmpiler nicht meckert wäre dies auch noch ein anderer Typ als das T der Klasse.
Aber noch einmal ganz klar und deutlich: Dein HeapSort muss kein Compatable implementiert. Das ist eine Anforderung später an die Verwendung der Klasse HeapSort.
HeapSort erwartet, dass Du einen Typ angibst, der Comparable implementiert.
HeapSort implementiert das CompareTo nicht! Und Deine Implementierung ist einfach nur Quatsch! Comparable<T> müsste eine Methode
int CompareTo(T o1, T o2);
implementieren.
Der Code, den Du da zeigst:
a) implementiert kein Compareable
b) Erzeigt einen eigenen Generic T - so der COmpiler nicht meckert wäre dies auch noch ein anderer Typ als das T der Klasse.
Aber noch einmal ganz klar und deutlich: Dein HeapSort muss kein Compatable implementiert. Das ist eine Anforderung später an die Verwendung der Klasse HeapSort.
Heißt, ich muss die CompareTo Methode nicht ausprogrammieren, sondern meine T's tun es bereits...? Ich kann also auf meine T's die CompareTo-Methode aufrufen? t1.compareTo(t2) wobei t1 und t2 T's sind.
Heißt, ich muss die CompareTo Methode nicht ausprogrammieren, sondern meine T's tun es bereits...? Ich kann also auf meine T's die CompareTo-Methode aufrufen? t1.compareTo(t2) wobei t1 und t2 T's sind.
Genau. Mit der Generics Definition sagst du:
T kann ein beliebiger Typ sein. Einzige Bedingung ist, dass T das Interface Comparable implementieren muss. Dementsprechend ist das einzige, was du bzgl. T weißt, dass es auf jeden Fall die Methode compareTo(T other) implementiert.
Heißt, ich muss die CompareTo Methode nicht ausprogrammieren, sondern meine T's tun es bereits...? Ich kann also auf meine T's die CompareTo-Methode aufrufen? t1.compareTo(t2) wobei t1 und t2 T's sind.
Heißt, ich muss die CompareTo Methode nicht ausprogrammieren, sondern meine T's tun es bereits...? Ich kann also auf meine T's die CompareTo-Methode aufrufen? t1.compareTo(t2) wobei t1 und t2 T's sind.
Oben siehst du unter "All implemented Interfaces", dass String Comparable implementiert. Du kannst also deinen HeapSort Klasse direkt mit String verwenden: HeapSort<String> stringSorter = new HeapSort<>();
