Methodenkopf

Bitte aktiviere JavaScript!
Hallo,
ich will einen Sortieralgorithmus implementieren. Dazu habe ich folgenden Methodenkopf gegeben, den ich nicht ganz verstehe:
Java:
public static <T extends Comparable<? super T>> void sort(List<T> list) {
Was heißt das genau.
Wenn ich nur
Java:
public static <T extends Comparable> void sort(List<T> list) {
hätte, dann könnte ich doch Instanzen eines bestimmten Typs T miteinander vergleichen.
Aber was bedeutet das im Kontext mit super T?
 
A

Anzeige




Schau mal hier —> (hier klicken)
Das java.lang.Comparable Interface ist auch typparametrisiert. Wenn du nur <T extends Comparable> schreibst, ist nicht sichergestellt, dass ein T in deiner Liste auch Comparable auf sich selbst implementiert. Comparable ist an dieser Stelle dann ein "Raw-Type" und du bekommst Compiler-Warnungen. Da könnten dann auch Listenelement vom Typ:
Java:
public class ListElementType implements Comparable<String> {
  public int compareTo(String str) {...}
}
drin sein. Die Sortierung muss aber sicherstellen, dass die Elemente auch sich selbst vergleichen können. Das "super" darin sagt dann nur noch, dass ein T nicht "nur" sich selbst vergleichen darf, sondern auch Unterklassen von sich selbst. "super" dann deshalb, weil das erlaubte Typargument von Comparable zumindest T als Supertyp haben muss (darf aber auch abgeleitet sein).
 
Hallo,
ich verstehe nicht, was du damit meinst:
," dass ein T in deiner Liste auch Comparable auf sich selbst implementiert."

wie kann ich dann die compareTo Methode für eine allgemeine Liste von Objekten in der Sortiermethode zum Vergleich verwenden. Im Interface steht ja nur der Rumpf, d,h ich müsste diese implementieren.
Aber wie soll das für den allgemeinen Typ T gehen?
 
Das implementieren die Klassen der Objekte, die du in deiner Sortieren-Methode vergleichen möchtest - also die Objekte in der Liste.
Weißt ja: Polymorphie und Objektorientierung und so...
 
Alles klar:)
Nochmal zu dem super T:
D.h wenn ich eine Klasse Person habe, die Comperable<Person> implementiert. Dann können auch Objekte der Unterklasse Student miteinander verglichen werden?
 
Genauer gesagt, ist dann (und nur dann) möglich, dass eine Oberklasse (also z.B. Person) `Comparable<Person>` implementiert, es eine Unterklasse `Student extends Person` gibt und du trotzdem sort() mit einem `List<Student>` aufrufen kannst, obwohl ja die Klasse Student nicht `Comparable<Student>` implementiert.

In Code ausgedrückt:
Java:
class Person implements Comparable<Person> {
  public int compareTo(Person o) {...}
}
class Student extends Person {}
public static <T extends Comparable<? super T>> void sort(List<T> list) {
  ...
}
public static void main(String[] args) {
  List<Student> persons = new ArrayList<>();
  sort(persons); // <- funktioniert wegen <? super T>
}
Ja, allerdings auch Student mit Professor
Das wäre nur möglich, wenn Student und Professor in einer Vererbungslinie sind, wären sie aber nicht.
 
Aha gut, d.h also egtl, wie man es von der Vererbung kennt, dass die Methode sort() vererbt wird und entsprechend für den Unterklassentyp aufgerufen werden kann. Das ist aber nur in Verbindung mit dem Interface Comparable nur möglich mit dem super T.
Kann man das so sagen?
 
Das ist gewissermaßen eine zusätzliche Einschränkung, nicht nur müssen A alle Elems Comparable sein, nein sondern auch alle Comparable Elems müssen B dieselben/ die gleichen (Typ) sein. Damit verhindert man gewissermaßen, Äpfel und Birnen zu vergleichen/ zu sortieren....
Obs sinnvoll ist, sei mal in den Raum gestellt
 
Nein, es handelt sich bei `<? super T>` eben nicht um dengleichen/denselben Typen wie die Typen der Listenelemente. Derselbe Typ wäre nur `<T>`. Wie bereits in dem Beispiel gezeigt, dient `<? super T>` dazu, Vererbung in den Listenelementtypen zu erlauben. T muss nicht `Comparable<T>` implementieren, sondern kann auch von einer Klasse `S` erben, welche `Comparable<S>` implementiert.
Und das ist sehr sinnvoll.
 
Das wäre nur möglich, wenn Student und Professor in einer Vererbungslinie sind, wären sie aber nicht.
Ich meinte, dass auch sowas möglich ist:

Java:
class Person implements Comparable<Person> {
  public int compareTo(Person o) {...}
}
class Student extends Person {}
class Prof extends Person {}


public static <T extends Comparable<? super T>> void sort(List<T> list) {
  ...
}
public static void main(String[] args) {
  List<Person> persons = new ArrayList<>();
  persons.add(new Prof());
  persons.add(new Student());
  sort(persons);
}
 
Sinnvoll ist das zudem nur sehr bedingt.
Korrekt. Und die Bedingung ist: true ;)

Spaß beiseite: Es erlaubt dir, eine Liste eines konkreten statischen Typs (wie eben z.B. `List<Student>`) für eine Sortierung zu verwenden, wenn eben nicht Student `Comparable<Student>` implementiert, sondern eine Oberklasse. Wann ist das sinnvoll? Wenn du in einem bestimmten Kontext tatsächlich nur eine Liste von Studenten (und eben nicht Personen) haben möchtest. Du möchtest also statisch sicherstellen, dass die Liste auch nur Studenten und genau Studenten hat. Und für die Sortierung möchtest du jetzt nicht das ganze nochmal statisch casten zu einem `List<Person>`, nur um diese Liste sortieren zu können.
Das `<? super T>` erweitert also die möglichen Typen, mit denen man die Methode aufrufen kann.
 
Ok alles klar.
Ich habe versucht, ein Sortierverfahren mit meinem gegebenen Methodenkopf zu implementieren.
Java:
public static <T extends Comparable<? super T>> void sort(List<T> list) {
        
       for(int j = 1 ; j < list.size(); j++){
           T elem=list.get(j);
           int i=j-1;
           while(i>0 && (elem.compareTo(list.get(i))<0)){
               list.set(i+1,list.get(i));     
               i--;
           }
           list.set(i+1,elem);
        
       }
Wäre das ok?
 
Das Problem ist, dass ich es nicht kann. In Eclipse werden die Methoden size() und get werden nicht gefunden, obwohl ich das passende importiert habe. Wie kann ich das lösen?
 
A

Anzeige




Vielleicht hilft dir das hier weiter: (klicke hier)
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben