Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 9 - OOP III: Interfaces

## 9.2 Das Interface Comparable

- 9.2 Das Interface Comparable

Interfaces werden verwendet, um Eigenschaften auszudrücken, die auf Klassen aus unterschiedlichen Klassenhierarchien zutreffen können. Das erkennt man auch daran, daß ihre Namen oft (substantivierte) Eigenschaftswörter sind. Ein bekanntes Beispiel, das mit der Version 1.2 in der Java-Klassenbibliothek eingeführt wurde, ist das Interface `Comparable` des Pakets `java.lang`:

    public interface Comparable
    {
      public int compareTo(Object o);
    }

Dieses Interface kann von Klassen implementiert werden, deren Objekte paarweise vergleichbar sind. Die Methode `compareTo` liefert genau dann einen Wert kleiner 0, wenn das Objekt »kleiner«; größer 0, wenn es »größer«, und gleich 0, wenn es »gleich« dem als Argument übergebenen Objekt `o` ist. In der Klassenbibliothek gibt es eine ganze Reihe von Klassen, die `Comparable` implementieren, beispielsweise `String` und `Character` oder die numerischen Wrapper-Klassen (letztere werden in Abschnitt 10.2 erläutert).

Mit Hilfe von `Comparable` kann die Reihenfolge der Objekte einer Klasse ermittelt werden. Aus dem paarweisen Vergleich läßt sich eine (nicht notwendigerweise eindeutige) implizite Ordnung der Elemente ableiten, denn für alle aufeinanderfolgenden Objekte `a` und `b` muß `a.compareTo(b) <= 0` gelten. Damit ist es möglich, Methoden zu schreiben, die das kleinste oder größte Element einer Menge von Objekten ermitteln oder diese sortieren:

    001 /* Listing0907.java */
    002
    003 public class Listing0907
    004 {
    005   public static Object getSmallest(Comparable[] objects)
    006   {
    007     Object smallest = objects[0];
    008     for (int i = 1; i < objects.length; ++i) {
    009       if (objects[i].compareTo(smallest) < 0) {
    010         smallest = objects[i];
    011       }
    012     }
    013     return smallest;
    014   }
    015
    016   public static void bubbleSort(Comparable[] objects)
    017   {
    018     boolean sorted;
    019     do {
    020       sorted = true;
    021       for (int i = 0; i < objects.length - 1; ++i) {
    022         if (objects[i].compareTo(objects[i + 1]) > 0) {
    023           Comparable tmp = objects[i];
    024           objects[i] = objects[i + 1];
    025           objects[i + 1] = tmp;
    026           sorted = false;
    027         }
    028       }
    029     } while (!sorted);
    030   }
    031
    032   public static void main(String[] args)
    033   {
    034     //Erzeugen eines String-Arrays
    035     Comparable[] objects = new Comparable[4];
    036     objects[0] = "STRINGS";
    037     objects[1] = "SIND";
    038     objects[2] = "PAARWEISE";
    039     objects[3] = "VERGLEICHBAR";
    040     //Ausgeben des kleinsten Elements
    041     System.out.println((String)getSmallest(objects));
    042     System.out.println("--");
    043     //Sortieren und Ausgaben
    044     bubbleSort(objects);
    045     for (int i = 0; i < objects.length; ++i) {
    046       System.out.println((String)objects[i]);
    047     }
    048   }
    049 }
| Listing0907.java

Listing 9.7: Das Interface Comparable

Die Implementierung der Methode `getSmallest` ist leicht zu verstehen. Das kleinste Element wird gefunden, indem jedes Element des Arrays mit dem bis dato kleinsten Element verglichen wird. Ist es kleiner, wird das bisherige kleinste Element ersetzt, andernfalls bleibt es unverändert. Die Implementierung von `bubbleSort` folgt ebenfalls einem einfachen Schema. In jedem Arraydurchlauf werden zwei aufeinanderfolgende Elemente vertauscht, falls das zweite kleiner als das erste ist. Es werden so viele Durchläufe vorgenommen, bis keine Vertauschung mehr stattgefunden hat.

Bemerkenswert ist hierbei die Generizität (Typunabhängigkeit) der Lösung. Es spielt keine Rolle, welche Art von Objekten sortiert wird, solange alle das Interface `Comparable` implementieren. Bei Strings ist das standardmäßig der Fall; eigene Klassen könnten ihre eigene Implementierung von `Comparable` beisteuern. Bei Objekten, die auch `Groesse` implementieren, könnte beispielsweise das Volumen (Länge mal Breite mal Höhe) oder eine beliebige andere Verknüpfung der Raumlängen verwendet werden.

|  |  |  | Auch Objekte unterschiedlicher Klassen können problemlos miteinander verglichen werden, sofern `compareTo` dazu in der Lage ist. So ist es leicht vorstellbar, daß sowohl Autos als auch Fußballplätze und Papierblätter (und eventuell noch Äpfel und Birnen) auf der Basis ihrer Grundfläche (siehe Listing 9.5) miteinander verglichen werden, denn diese Maßzahl hat für alle beteiligten Klassen eine Bedeutung. |  |
Tip

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de