Kapitel 5: Interfaces

Liste P: Programmieren mit Java
WS 2001/2002
Prof. Dr. V. Turau
FH Wiesbaden
Kapitel 5: Interfaces
Folie 82 : Einleitung
Betrachtet man die Programmierleistung für ein Produkt über einen längeren Zeitraum, so
stellt man fest, das die eigentliche Entwicklungszeit meist unter 20% liegt.
Der größte Zeitanteil entfällt auf Wartungs- und Änderungsarbeiten
Dies sollte bei der Softwareentwicklung berücksichtigt werden:
Coderedundanz vermeiden
Erweiterungsmöglichkeiten einplanen
Dokumentation
....
Folie 83 : Interfaces
Bei der Zerlegung eines Problems in Teilprobleme und deren Lösung durch einzelne Klasse
sind zunächst nur die öffentlichen Methoden interessant, welche eine Klasse anbieten muss
Die Implementierung der Klasse muss diese Methoden dann zur Verfügung stellen
Damit zu einem späteren Zeitpunkt eine Klasse durch eine andere ersetzt werden kann, muss
diese die gleichen Methoden anbieten
Eine Realisierungsmöglichkeit sind Unterklassen, d.h. die neue Klasse ist eine Unterklasse
der alten Klasse
Folie 84 : Interfaces
Dies kann jedoch zu ungewollten Abhängigkeiten und Einschränkungen führen
Java bietet die Möglichkeit eine Schnittstelle zu vereinbaren, dies geschieht mit Interfaces
Ein Interface vereinbart eine Reihe von abstrakten Methoden
Die Angabe eine Implementierung ist nicht möglich
Interfaces führen wie Klassen neue Referenztypen ein, d.h. der Typ einer Variable kann ein
Interface sein
Solchen Variablen dürfen nur Objekte zugewiesen werden, deren Klassen das vereinbarte
Interface implementieren
Folie 85 : Vereinbarung von Interfaces
Innerhalb eines Paketes bilden die Namen von Klassen und Interfaces einen Namensraum,
d.h. die Namen müssen alle verschieden sein
Vereinbarung:
[public] [abstract] interface Name { ... }
Der Modifier abstract ist zwar erlaubt, hat aber keine weitere Bedeutung
Der Modifier public hat die gleiche Bedeutung wie bei Klassen
Vereinbarungen von Interfaces werden wie Klassenvereinbarungen in separaten Dateien mit
der Endung java abgespeichert
Folie 86 : Implementierung eines Interfaces
Eine Klasse kann mehrere Interfaces implementieren, dazu muss sie
Die Interfaces bei der Klasenvereinbarung angeben
class Name implements Interface1, Interface2 ..
Eine Implementierung für alle Methoden der angegebenen Interfaces bereitstellen
Bei der Vereinbarung zunächst die Oberklasse und dann die implementierten Interfaces
angeben
Der Compiler prüft, ob eine Klasse die angegebenen Interfaces implementiert
Folie 87 : Interfaces (Beispiel)
Um Objekte zu sortieren, muss eine Vergleichsrelation definiert sein
Beispiele:
Strings (alphabetisch)
Zahlen (die Größe)
Rechteck (die Fläache)
Das Interface Comparable vereinbart eine Methode zum Vergleichen von Objekten:
public interface Comparable {
public abstract int compareTo(Object o);
}
Folie 88 : Interfaces (Beispiel)
Der Rückgabewert von compareTo ist
negativ, wenn das Empfängerobjekt kleiner ist
0, wenn beide Objekte gleich sind
positiv, wenn das Empfängerobjekt größer ist
Zahlreiche Klassen implementieren dieses Interface
String
Date
Time
Folie 89 : Interfaces (Beispiel)
import java.awt.Point;
public class Punkt extends Point implements Comparable {
public Punkt(int x, int y) {
super(x,y);
}
/* Ein Punkt ist kleiner als ein anderer Punkt,
wenn er links von ihm liegt */
public int compareTo(Object o) {
if (this.x == ((Point)o).x)
return 0;
return (this.x < ((Point)o).x) ? -1 : 1;
}
}
Folie 90 : Interfaces (Beispiel)
Problem: Wird der Methode keine Instanz von Punkt übergeben, so kommt es zu einer
ClassCastException
Lösung:
public int compareTo(Object o) {
if (o instanceof Punkt) {
if (x == ((Point)o).x)
return 0;
return (x < ((Point)o).x) ? -1 : 1;
}
return -1;
}
Folie 91 : Interfaces (Anwendung)
Eine Klasse zum Sortieren von Objekten, welche das Interface Comparable implementieren
Die Klasse soll ein Feld mit Objekten, welche das Interface Comparable implementieren,
aufsteigend sortieren
Vorteil:
Die Sortierklasse kann zum Sortieren beliebiger Objekte verwendet werden
Lösung in C:
qsort(void *base, size_t n size_t size,
int (*cmp)(const void *, const void *));
Lösung in C++: Templates
Folie 92 : Shellsort
public class ShellSort {
public static void sort(Comparable[] o) {
for (int incr = o.length/2; incr > 0; incr /=2)
for (int i = incr; i < o.length; i++)
for (int j = i - incr; (j >= 0) &&
(o[j].compareTo(o[j+incr]) > 0); j -= incr) {
Comparable tmp = o[j];
o[j] = o[j+incr];
o[j+incr] = tmp;
}
}
}
Folie 93 : Anwendung
public class TestSort {
public static final int ANZAHL = 10, MAX = 30;
public static void main(String[] a) {
Punkt[] punkte = new Punkt[ANZAHL];
Random zufall = new Random();
for (int i = 0; i < punkte.length; i++) {
punkte[i] = new Punkt(zufall.nextInt()%MAX,
zufall.nextInt()%MAX);
System.out.print(punkte[i] + " " );
}
System.out.println();
ShellSort.sort(punkte);
for (int i = 0; i < punkte.length; i++)
System.out.print(punkte[i] + " " );
}
}
Folie 94 : Interfaces (Beispiel)
import java.util.*;
public class CompareVector extends Vector
implements Comparable {
/* Ein Vector ist kleiner als ein anderer Vector,
wenn er weniger Element hat */
public int compareTo(Object o) {
if (o instanceof Vector)
return x.size() - ((Point)o).size();
else
return -1;
}
}
Folie 95 : Eigene Interfaces
Der Quellcode eines Interfaces wird wie der einer Klasse in einer eigenen Datei abgespeichert
Interface-Name gleich Dateiname + Endung java
Interfaces werden wie Klasse übersetzt
Der übersetzte Code wird in einer Datei mit der Endung class abgelegt
Alle Members eines Interfaces sind implizit public und abstract (d.h. diese Modifier
müssen nicht angegeben werden)
Eine Klasse kann mehrere Interfaces implementieren
Folie 96 : Statische Konstanten
Interfaces können neben Methoden auch statische Konstanten vereinbaren
Beispiel Interface SocketOptions
public interface SocketOptions {
public static final int SO_TIMEOUT = 4102;
public static final int SO_BINDADDR = 15;
....
}
Verwendung:
System.out.println(SocketOptions.SO_TIMEOUT);
Variablen in Interfaces sind implizit public, static und final (d.h. diese Modifier müssen
nicht angegeben werden)
Folie 97 : Das Interfaces Enumeration
Das Interface java.util.Enumeration vereinbart einen Iterator
Methoden:
public boolean hasMoreElements();
public Object nextElement();
Verwendung:
Enumeration e = ...;
while (e.hasMoreElements()) {
Object o = e.nextElement();
...
}
Achtung: Rückgabetyp von nextElement() ist Object, in der Regel ist ein Typ-Cast
notwendig
Folie 98 : Das Interfaces Enumeration
Beispiele:
public Enumeration elements();
Klasse Vector
public Enumeration keys();
Klasse Hashtable
public Enumeration propertyNames(); Klasse Properties
Anwendung in der Klasse Element in Kapitel 4:
protected void printAttribute(PrintWriter w) {
Enumeration enum = attribute.propertyNames();
while (enum.hasMoreElements()) {
String name = (String) enum.nextElement();
w.print(’ ’ + name + "=’" +
attribute.getProperty(name) + "’");
}
}
Folie 99 : Erweiterung von Interfaces
Interfaces können andere Interfaces erweitern
Vereinbarung:
interface Name [extends Interface1 [, Interface2, ..]]
Bedeutung: wie bei Klassen, alle Methoden werden geerbt.
Beispiel:
public interface Ordnung extends Comparable {
public boolean equals(Object o);
}