Verträge – Interfaces im JDK
Diese Woche schauen wir in viele Bereiche des JDK: Collections, Dateien, Nebenläufigkeit, Datenbanken. Überall begegnet uns dasselbe Muster: Das JDK legt einen Vertrag fest – ein Interface –, und Implementierungen davon gibt es viele, manche im JDK, manche von ganz anderen Herstellern. Dieses Muster bauen wir zuerst einmal selbst nach.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- erklären, was ein Interface als Vertrag zwischen zwei Seiten bedeutet
- aus einer fertigen Klasse mit IntelliJ ein Interface herausziehen
- einen Vertrag im Javadoc so genau beschreiben, dass ihn andere umsetzen können
- ein Interface implementieren, das jemand anderes geschrieben hat
Demo-Code: 20-roemisch
⤓ demo-roemisch.zip herunterladenDer fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.
Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner 20-roemisch wählen → OK → Trust Project. Zeigt IntelliJ oben Project JDK is not defined: auf Setup SDK klicken und das JDK 21 wählen. Die Startkonfiguration Anwendung ist schon eingerichtet.
Enthält: Umrechner.java, Anwendung.java, Pruefung.java, RoemischerUmrechner.java
Spezifikation, Referenz, Prüfung
Abschnitt betitelt „Spezifikation, Referenz, Prüfung“In Was ist Java? haben wir gesehen: Was „Java SE“ ist, legt eine Spezifikation fest. Das OpenJDK ist die Referenzimplementierung, und jedes andere JDK – auch Temurin – muss das TCK bestehen, die offizielle Testsammlung.
Dasselbe Muster gibt es im Kleinen, für einzelne Teile der Bibliothek. Das bekannteste Beispiel ist JDBC, der Datenbankzugriff:
| bei JDBC | in diesem Kapitel | |
|---|---|---|
| Spezifikation | die Interfaces im Package java.sql: Connection, Statement, ResultSet … |
das Interface Umrechner |
| Implementierung | ein Treiber vom Datenbankhersteller – für PostgreSQL, Oracle, DB2 … | eure Klassen, eine pro Person |
| Prüfung | das TCK für JDBC | das Programm Pruefung |
| Anwendung | dein Programm – es kennt nur java.sql |
das Programm Anwendung |
Das Entscheidende: Wer ein Programm mit JDBC schreibt, programmiert nur gegen die Interfaces. Welche Datenbank dahintersteht, merkt das Programm nicht – der Treiber lässt sich austauschen, ohne dass sich eine Zeile ändert.
Die Aufgabe: römische Zahlen
Abschnitt betitelt „Die Aufgabe: römische Zahlen“Wir brauchen eine Klasse, die zwischen Zahlen und römischen Zahlen umrechnet.
| I | V | X | L | C | D | M |
|---|---|---|---|---|---|---|
| 1 | 5 | 10 | 50 | 100 | 500 | 1000 |
- Die Zeichen werden von groß nach klein geschrieben und addiert:
MMXXVI= 1000 + 1000 + 10 + 10 + 5 + 1 = 2026. - Steht ein kleineres Zeichen vor einem größeren, wird es abgezogen – aber
nur in sechs Fällen:
IV(4),IX(9),XL(40),XC(90),CD(400),CM(900). So wirdMCMXCIVzu 1000 + 900 + 90 + 4 = 1994. - Kein Zeichen steht mehr als dreimal hintereinander. Deshalb ist 3999
(
MMMCMXCIX) die größte Zahl, die sich so schreiben lässt. Eine Null gibt es nicht.
Erster Entwurf: eine Klasse
Abschnitt betitelt „Erster Entwurf: eine Klasse“Welche Methoden braucht die Klasse? Eine für jede Richtung – und eine, die sagt, wer sie geschrieben hat:
package de.drv.roemisch;
public class RoemischerUmrechner {
public String zuRoemisch(int zahl) { throw new UnsupportedOperationException("Noch nicht implementiert"); }
public int vonRoemisch(String text) { throw new UnsupportedOperationException("Noch nicht implementiert"); }
public String getHersteller() { return "Dummy"; }
}Die Methoden sind nur Platzhalter – wie in der Übung zum dynamischen
Array: Sie werfen eine UnsupportedOperationException, „diese Operation wird
nicht unterstützt“. So meldet auch das JDK selbst, dass eine Methode zwar zum
Vertrag gehört, hier aber nicht funktioniert. Du wirst ihr bei den Collections
wiederbegegnen.
Damit können wir das Programm schreiben, das die Klasse benutzt – auch wenn sie noch nichts kann:
package de.drv.roemisch;
/** Rechnet die Programmargumente um: Zahlen in römische Zahlen und umgekehrt. */public class Anwendung {
public static void main(String[] args) { RoemischerUmrechner umrechner = new RoemischerUmrechner();
System.out.println("Umrechner von " + umrechner.getHersteller()); for (String argument : args) { if (Character.isDigit(argument.charAt(0))) { int zahl = Integer.parseInt(argument); System.out.println(zahl + " = " + umrechner.zuRoemisch(zahl)); } else { System.out.println(argument + " = " + umrechner.vonRoemisch(argument)); } } }
}Gestartet mit den Argumenten 1994 MCMXCIV:
Umrechner von DummyException in thread "main" java.lang.UnsupportedOperationException: Noch nicht implementiert at de.drv.roemisch.RoemischerUmrechner.zuRoemisch(RoemischerUmrechner.java:6) at de.drv.roemisch.Anwendung.main(Anwendung.java:13)Das Programm übersetzt und läuft – es scheitert erst an der fehlenden Implementierung. Genau das wollen wir: Die Anwendung ist fertig, bevor es die Umrechnung ist.
Von der Klasse zum Vertrag
Abschnitt betitelt „Von der Klasse zum Vertrag“Jetzt sollen viele Leute den Umrechner schreiben – jeder seine eigene Version. Dafür trennen wir, was ein Umrechner können muss, von dem, wie er es macht.
Das Interface herausziehen
Abschnitt betitelt „Das Interface herausziehen“IntelliJ erledigt das in einem Schritt:
-
Setze den Cursor in die Klasse
RoemischerUmrechnerund wähle Refactor → Extract Interface…. -
Trage als Namen
Umrechnerein und setze bei allen drei Methoden das Häkchen. -
Klicke auf Refactor. IntelliJ fragt, ob es das Interface überall verwenden soll, wo das möglich ist – bestätige mit Refactor.
Das Interface steht jetzt in de.drv.roemisch, die Klasse hat ein
implements Umrechner bekommen, und ihre Methoden tragen @Override. In der
Anwendung hat IntelliJ den Typ der Variablen geändert:
Umrechner umrechner = new RoemischerUmrechner();Die Implementierung ausziehen lassen
Abschnitt betitelt „Die Implementierung ausziehen lassen“Die Spezifikation gehört in ein eigenes Package – die Implementierungen nicht.
Klicke mit rechts auf RoemischerUmrechner → Refactor → Move Class… (F6)
und trage als Ziel de.drv.roemisch.dummy ein. IntelliJ legt das Package an und
ergänzt in der Anwendung den import.
Ordnersrc
Ordnerde
Ordnerdrv
Ordnerroemisch die Spezifikation und ihre Nutzer
- Umrechner.java das Interface
- Anwendung.java
- Pruefung.java
Ordnerdummy eine Implementierung
- RoemischerUmrechner.java
Schau dir die Anwendung noch einmal an: Nur eine Zeile nennt die Klasse
RoemischerUmrechner – die mit new. Alles andere spricht nur mit dem
Umrechner. Wer die Implementierung austauschen will, ändert genau diese Zeile.
Der Vertrag im Javadoc
Abschnitt betitelt „Der Vertrag im Javadoc“Ein Interface sagt, welche Methoden es gibt. Was sie genau tun sollen – vor
allem in den Randfällen –, steht im Javadoc. Ohne diese Beschreibung würde
jeder etwas anderes bauen: Was passiert bei 0? Bei "iv" in Kleinbuchstaben?
Bei "IIII"?
package de.drv.roemisch;
/** * Rechnet zwischen ganzen Zahlen und römischen Zahlen um. * * <p>Römische Zahlen werden in der üblichen Schreibweise mit den Zeichen I, V, X, L, C, D * und M dargestellt. Steht ein kleineres Zeichen vor einem größeren, wird es abgezogen – * aber nur in diesen sechs Fällen: IV (4), IX (9), XL (40), XC (90), CD (400) und CM (900). * Darstellbar sind damit die Zahlen von 1 bis 3999. */public interface Umrechner {
/** * Wandelt eine Zahl in eine römische Zahl um, z. B. 1994 in {@code "MCMXCIV"}. * * @param zahl eine Zahl von 1 bis 3999 * @return die römische Zahl in Großbuchstaben, in der kürzesten üblichen Schreibweise * @throws IllegalArgumentException wenn die Zahl kleiner als 1 oder größer als 3999 ist */ String zuRoemisch(int zahl);
/** * Wandelt eine römische Zahl in eine Zahl um, z. B. {@code "MCMXCIV"} in 1994. * * <p>Groß- und Kleinschreibung spielt keine Rolle. Angenommen wird nur die übliche * Schreibweise, also genau das, was {@link #zuRoemisch(int)} liefert: {@code "IV"}, aber * nicht {@code "IIII"}; {@code "XC"}, aber nicht {@code "LXL"}. * * @param text eine römische Zahl * @return die Zahl von 1 bis 3999 * @throws IllegalArgumentException wenn {@code text} {@code null}, leer oder keine römische * Zahl in der üblichen Schreibweise ist */ int vonRoemisch(String text);
/** * Wer diese Implementierung geschrieben hat. * * @return ein Name, nie {@code null} oder leer */ String getHersteller();
}Das ist der vollständige Vertrag. Wer ihn umsetzt, darf sich auf nichts verlassen, was hier nicht steht – und muss alles erfüllen, was hier steht.
Die Prüfung
Abschnitt betitelt „Die Prüfung“Woher weiß ein Hersteller, ob seine Implementierung den Vertrag erfüllt? Er
lässt das TCK laufen. Unser TCK ist das Programm Pruefung: Es ruft jede
eingetragene Implementierung mit festen Werten auf und zählt, was stimmt.
Pruefung.java
package de.drv.roemisch;
/** * Prüft Implementierungen von {@link Umrechner} gegen den Vertrag – so wie das * Technology Compatibility Kit (TCK), das jedes JDK bestehen muss. */public class Pruefung {
public static void main(String[] args) { // Hier jede Implementierung eintragen – mit vollem Namen, denn alle heißen gleich. Umrechner[] alle = { new de.drv.roemisch.dummy.RoemischerUmrechner(), };
Ergebnis[] ergebnisse = new Ergebnis[alle.length]; for (int i = 0; i < alle.length; i++) { ergebnisse[i] = pruefe(alle[i]); }
System.out.println(); System.out.printf("%-20s %12s %12s %12s%n", "Hersteller", "zuRoemisch", "vonRoemisch", "Fehlerfälle"); for (Ergebnis ergebnis : ergebnisse) { System.out.println(ergebnis); } }
/** Wie viele Prüfungen einer Implementierung in jedem Bereich bestanden sind. */ record Ergebnis(String hersteller, int zu, int von, int fehler) {
@Override public String toString() { return String.format("%-20s %9d/%-2d %9d/%-2d %9d/%-2d", hersteller, zu, ZAHLEN.length, von, ZAHLEN.length + 1, fehler, FALSCHE_ZAHLEN.length + FALSCHE_TEXTE.length); } }
// Zahlen und ihre römische Schreibweise – geprüft in beide Richtungen private static final int[] ZAHLEN = {1, 3, 4, 9, 14, 40, 90, 400, 1994, 2026, 3888, 3999}; private static final String[] ROEMISCH = { "I", "III", "IV", "IX", "XIV", "XL", "XC", "CD", "MCMXCIV", "MMXXVI", "MMMDCCCLXXXVIII", "MMMCMXCIX", };
// Was eine IllegalArgumentException auslösen muss private static final int[] FALSCHE_ZAHLEN = {0, -1, 4000}; private static final String[] FALSCHE_TEXTE = {null, "", "ABC", "IIII", "VV", "IC", "XM", "LXL", "MMMM"};
/** Höchstens so viele Meldungen pro Implementierung, damit die Ausgabe lesbar bleibt. */ private static final int MAX_MELDUNGEN = 3; private static int meldungen;
private static Ergebnis pruefe(Umrechner umrechner) { String hersteller = umrechner.getHersteller(); System.out.println("Prüfe " + hersteller + " …"); meldungen = 0; int zu = 0; int von = 0; int fehler = 0;
for (int i = 0; i < ZAHLEN.length; i++) { if (zuRoemischStimmt(umrechner, ZAHLEN[i], ROEMISCH[i])) { zu++; } if (vonRoemischStimmt(umrechner, ROEMISCH[i], ZAHLEN[i])) { von++; } } // Groß- und Kleinschreibung spielt keine Rolle if (vonRoemischStimmt(umrechner, "mcmxciv", 1994)) { von++; }
for (int zahl : FALSCHE_ZAHLEN) { try { melde("zuRoemisch(" + zahl + ") liefert " + umrechner.zuRoemisch(zahl) + " statt einer Exception"); } catch (IllegalArgumentException e) { fehler++; } catch (RuntimeException e) { melde("zuRoemisch(" + zahl + ") wirft " + e); } } for (String text : FALSCHE_TEXTE) { try { melde("vonRoemisch(" + zeige(text) + ") liefert " + umrechner.vonRoemisch(text) + " statt einer Exception"); } catch (IllegalArgumentException e) { fehler++; } catch (RuntimeException e) { melde("vonRoemisch(" + zeige(text) + ") wirft " + e); } }
if (meldungen > MAX_MELDUNGEN) { System.out.println(" … und " + (meldungen - MAX_MELDUNGEN) + " weitere"); } return new Ergebnis(hersteller, zu, von, fehler); }
private static boolean zuRoemischStimmt(Umrechner umrechner, int zahl, String erwartet) { try { String ergebnis = umrechner.zuRoemisch(zahl); if (erwartet.equals(ergebnis)) { return true; } melde("zuRoemisch(" + zahl + ") liefert " + zeige(ergebnis) + ", erwartet " + zeige(erwartet)); } catch (RuntimeException e) { melde("zuRoemisch(" + zahl + ") wirft " + e); } return false; }
private static boolean vonRoemischStimmt(Umrechner umrechner, String text, int erwartet) { try { int ergebnis = umrechner.vonRoemisch(text); if (ergebnis == erwartet) { return true; } melde("vonRoemisch(" + zeige(text) + ") liefert " + ergebnis + ", erwartet " + erwartet); } catch (RuntimeException e) { melde("vonRoemisch(" + zeige(text) + ") wirft " + e); } return false; }
private static void melde(String meldung) { meldungen++; if (meldungen <= MAX_MELDUNGEN) { System.out.println(" " + meldung); } }
private static String zeige(String text) { return text == null ? "null" : "\"" + text + "\""; }
}Mit dem Platzhalter besteht der Dummy erwartungsgemäß nichts:
Prüfe Dummy … zuRoemisch(1) wirft java.lang.UnsupportedOperationException: Noch nicht implementiert vonRoemisch("I") wirft java.lang.UnsupportedOperationException: Noch nicht implementiert zuRoemisch(3) wirft java.lang.UnsupportedOperationException: Noch nicht implementiert … und 34 weitere
Hersteller zuRoemisch vonRoemisch FehlerfälleDummy 0/12 0/13 0/12- zuRoemisch und vonRoemisch: richtige Ergebnisse für gültige Werte.
- Fehlerfälle: Ungültige Eingaben wie
0,4000,null,"IIII"oder"IC"müssen eineIllegalArgumentExceptionauslösen – so steht es im Vertrag.
Übung: Werde Hersteller
Abschnitt betitelt „Übung: Werde Hersteller“Schreibe deine eigene Implementierung des Umrechners. Am Ende sammeln wir alle
Implementierungen ein – und ein einziges Programm prüft sie alle.
Die Regeln
Abschnitt betitelt „Die Regeln“Damit alle Implementierungen am Ende in ein Projekt passen:
- Dein Package heißt
de.drv.und dein Vorname – nur Kleinbuchstaben, ohne Umlaute und Bindestriche:de.drv.anna,de.drv.juergen. Gibt es den Namen zweimal, hängt ihr den ersten Buchstaben des Nachnamens an:de.drv.annam. - Deine Klasse heißt
RoemischerUmrechnerund implementiertUmrechner. Alle Klassen heißen gleich – das Package unterscheidet sie. getHersteller()liefert deinen Namen.- Du verwendest nur das Interface, das JDK und Klassen aus deinem eigenen Package. Am Interface änderst du nichts.
So kommst du voran
Abschnitt betitelt „So kommst du voran“Lege dein Package an und darin die Klasse. Schreibe dazu nur die erste Zeile:
public class RoemischerUmrechner implements Umrechner {}IntelliJ unterstreicht sie rot – die Methoden fehlen noch. Alt+Enter →
Implement methods erzeugt alle drei. Trage deine Klasse dann in der
Pruefung ein:
Umrechner[] alle = { new de.drv.roemisch.dummy.RoemischerUmrechner(), new de.drv.anna.RoemischerUmrechner(),};Jetzt kannst du nach jedem Schritt prüfen, wie weit du bist. Arbeite die Stufen der Reihe nach ab:
zuRoemischfür gültige Zahlen. Tipp: Gehe die Werte von groß nach klein durch und ziehe sie ab, solange es geht – die sechs Subtraktionsfälle behandelst du einfach als eigene „Zeichen“ mit zwei Buchstaben.vonRoemischfür gültige Texte, auch in Kleinbuchstaben.- Fehlerfälle: Zahlen außerhalb von 1 bis 3999 und ungültige Texte führen zu
einer
IllegalArgumentExceptionmit einer verständlichen Meldung. - Für Schnelle: Stelle in der
Anwendungdeine Implementierung ein und fange dort dieIllegalArgumentExceptionab, sodass das Programm bei einem falschen Argument eine Meldung ausgibt und mit dem nächsten weitermacht.
Kopiere den Ordner deines Packages – etwa src\de\drv\anna – mit allen Dateien
darin auf das Gruppenlaufwerk. Lass vorher noch einmal die Pruefung laufen.
Alle zusammen
Abschnitt betitelt „Alle zusammen“Zum Schluss kommen alle Packages vom Gruppenlaufwerk in ein Projekt, und
jede Implementierung wird in der Pruefung eingetragen. Das Programm kennt keine
einzige davon – nur den Umrechner. Trotzdem läuft es mit allen. So kann das
Ergebnis aussehen:
Hersteller zuRoemisch vonRoemisch FehlerfälleDummy 0/12 0/13 0/12Anna 12/12 13/13 12/12Ben 12/12 12/13 3/12Clara 4/12 0/13 0/12Und das ist der Kern dieses Kapitels: Wer gegen ein Interface programmiert, kann jede Implementierung einsetzen, die den Vertrag erfüllt – auch eine, die es beim Schreiben des Programms noch gar nicht gab.
Lösung
Die Referenz-Implementierung arbeitet in beide Richtungen mit derselben Tabelle aus Werten und Zeichen – einschließlich der sechs Subtraktionsfälle.
Der Trick für die Fehlerfälle steckt am Ende von vonRoemisch: Statt alle
falschen Schreibweisen einzeln zu erkennen, macht die Methode die Probe. Sie
rechnet das Ergebnis mit zuRoemisch zurück. Kommt dabei nicht genau der
eingegebene Text heraus, war die Schreibweise nicht üblich – IIII ergibt 4,
aber 4 ergibt IV.
package de.drv.referenz;
import de.drv.roemisch.Umrechner;
/** Die Referenz-Implementierung: so kann eine fertige Lösung aussehen. */public class RoemischerUmrechner implements Umrechner {
// Von groß nach klein, mit den sechs Subtraktionsfällen dazwischen private static final int[] WERTE = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}; private static final String[] ZEICHEN = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
@Override public String zuRoemisch(int zahl) { if (zahl < 1 || zahl > 3999) { throw new IllegalArgumentException("Nur Zahlen von 1 bis 3999: " + zahl); } StringBuilder ergebnis = new StringBuilder(); int rest = zahl; for (int i = 0; i < WERTE.length; i++) { while (rest >= WERTE[i]) { ergebnis.append(ZEICHEN[i]); rest -= WERTE[i]; } } return ergebnis.toString(); }
@Override public int vonRoemisch(String text) { if (text == null || text.isEmpty()) { throw new IllegalArgumentException("Keine römische Zahl: " + text); } String gross = text.toUpperCase(); int summe = 0; int position = 0; for (int i = 0; i < WERTE.length; i++) { while (gross.startsWith(ZEICHEN[i], position)) { summe += WERTE[i]; position += ZEICHEN[i].length(); } } // Übrig gebliebene Zeichen oder eine unübliche Schreibweise wie IIII: Die Probe in // die Gegenrichtung muss genau den Text ergeben. if (position < gross.length() || summe < 1 || summe > 3999 || !zuRoemisch(summe).equals(gross)) { throw new IllegalArgumentException("Keine römische Zahl in üblicher Schreibweise: " + text); } return summe; }
@Override public String getHersteller() { return "Referenz"; }
}