From 33613a85afc4b1481367fbe92a17ee59c240250b Mon Sep 17 00:00:00 2001 From: Sven Eisenhauer Date: Fri, 10 Nov 2023 15:11:48 +0100 Subject: add new repo --- .../hjp5/html/k100059.html | 219 +++++++++++++++++++++ 1 file changed, 219 insertions(+) create mode 100644 Master/Reference Architectures and Patterns/hjp5/html/k100059.html (limited to 'Master/Reference Architectures and Patterns/hjp5/html/k100059.html') diff --git a/Master/Reference Architectures and Patterns/hjp5/html/k100059.html b/Master/Reference Architectures and Patterns/hjp5/html/k100059.html new file mode 100644 index 0000000..a689170 --- /dev/null +++ b/Master/Reference Architectures and Patterns/hjp5/html/k100059.html @@ -0,0 +1,219 @@ + + + +Handbuch der Java-Programmierung, 5. Auflage + + + + + + + + + +
 Titel  + Inhalt  + Suchen  + Index  + DOC  +Handbuch der Java-Programmierung, 5. Auflage +
 <<  +  <   +  >   + >>  + API  +Kapitel 9 - OOP III: Interfaces +
+
+ + + + +

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, dass 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 muss 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, dass 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.

 + + + + +
 Tipp 
+
+

+ + + +
 Titel  + Inhalt  + Suchen  + Index  + DOC  +Handbuch der Java-Programmierung, 5. Auflage, Addison +Wesley, Version 5.0.1 +
 <<  +  <   +  >   + >>  + API  +© 1998, 2007 Guido Krüger & Thomas +Stark, http://www.javabuch.de +
+ + + -- cgit v1.2.3