Kapitel 5.7-5.9

5.7
Interfaces
• Interfaces sind "Klassen ohne Methodenimplementierungen".
• Interfaces werden auch Schnittstellen genannt.
• Grundlegende Motivation:
– Trennung Spezifikation / Realisierung
– Ermöglichung von Mehrfachvererbung
• Motivation: Trennung Spezifikation / Realisierung
– Realisierung ist noch nicht bekannt, aber man weiß schon, was
realisiert werden soll.
– Man will mehrere auch konkurrierende Realisierungen zulassen und
dabei sicherstellen, daß gewisse Eigenschaften gewährleistet
werden.
– Die grundlegenden Eigenschaften werden durch Signaturen
festgelegt.
– Die Signatur einer Methode legt ihr Eingabe- / Ausgabeverhalten
fest, also die Typen der Eingabeparameter und den Rückgabewert.
Informatik I – Java
© Klaus Hinrichs
5-175
Interfaces
• Motivation: Mehrfachvererbung
• Mehrfacherbung (multiple inheritance) =
eine Klasse besitzt mehrere Oberklassen
Kraftfahrzeug
Schiff
Amphibienfahrzeug
© Klaus Hinrichs
Informatik I – Java
5-176
Interfaces
• Problem:
Welche Methode wird bei Namenskonflikten gewählt?
• Lösung:
In Java nicht möglich!
aber:
hilfreiches Ersatzkonstrukt verfügbar: Interface
Modifier interface Interfacename {
Konstanten-Deklarationen
Methoden-Deklarationen
}
© Klaus Hinrichs
Informatik I – Java
5-177
Vererbung bei Interfaces
•
extends ist das Schlüsselwort für Interfacevererbung:
interface Unterinterface extends Oberinterface {
Interfacebody
}
• Klassen erben von Interfaces über das Schlüsselwort implements.
• Klassen können von einem oder mehreren Interfaces und auch
zusätzlich von einer Oberklasse erben:
class NameUnterklasse extends NameOberklasse
implements Interface1, Interface2, ...
{ ... }
• Werden von einer Klasse nicht alle Methoden des Interfaces
implementiert, muß sie mit abstract gekennzeichnet werden.
• Analog zum Erben von Oberklassen ist Polymorphie möglich.
© Klaus Hinrichs
Informatik I – Java
5-178
Interfaces
• Die Supertypen einer Klasse A sind
– die Klasse B, von der A erbt,
– die Interfaces, die A implementiert, und
– die Supertypen dieser Klasse und Interfaces.
• Alle Interface-Methoden sind implizit public und abstract, denn:
public, weil alle realisierenden Klassen wissen müssen, was sie
realisieren sollen; abstract, weil das das Merkmal von Interfaces ist.
• Alle Attribute sind implizit public, static und final, denn: Es kann
nur um Konstanten gehen, die immer gleich verwendet werden (also
final). Diese braucht man dann nicht pro Objekt, sondern nur pro
Klasse (also static).
• Klasse ist abstrakt, wenn mindestens eine ihrer Methoden abstrakt ist
! Interface ist Spezialfall einer abstrakten Klasse, es hat ausschließlich abstrakte Methoden.
• Vorteil von Interfaces im Hinblick auf Mehrfachvererbung: ohne Implementierungen von Methoden kann es auch keine Konflikte geben.
© Klaus Hinrichs
Informatik I – Java
5-179
Abstrakte Klasse versus Interface
public interface Konto {
public void einzahlen();
public void auszahlen();
}
• Interface wird durch Klasse implementiert:
public class Girokonto implements Konto {
...
public void einzahlen() {
...
}
public void auszahlen() {
...
}
}
© Klaus Hinrichs
Informatik I – Java
5-180
Abstrakte Klasse versus Interface
• Interface kann als Typ für eine Referenz dienen, d. h. Interfaces
unterstützen polymorphes Verhalten wie Oberklassen:
Girokonto dasGiro = new Girokonto();
Konto kto = dasGiro;
kto.einzahlen(500);
Das durch kto referenzierte Objekt bestimmt die Methode, die
ausgeführt wird!
© Klaus Hinrichs
Informatik I – Java
5-181
Interfaces
• Interfaces können eigene Vererbungshierarchie bilden.
• Für Interfaces ist Mehrfacherbung erlaubt.
public interface X {
...
}
public interface Y {
...
}
public interface Z extends X, Y {
...
}
© Klaus Hinrichs
Informatik I – Java
5-182
Namenskonflikte …
• Problem:
interface W {}
interface X extends W {}
class Y implements W {}
class Z extends Y implements X {}
interface W {}
interface X extends W {}
interface Y extends W {}
class Z implements X, Y {}
W
X
Y
Z
W
X
Y
Z
• Gleichnamige Attribute: Referenzierung über
InterfaceName.Attribute
Informatik I – Java
© Klaus Hinrichs
5-183
… Namenskonflikte
• Was passiert, wenn eine Methode mit dem gleichen Namen in mehr
als einem zu realisierenden Interface vorkommt?
X
Y
Z
1. Fall:
Haben Methoden in Interfaces X und Y den gleichen Namen, aber verschiedene Anzahl bzw. Typen von Parametern, so hat Z zwei überladene Methoden mit gleichem Namen, aber verschiedenen Signaturen.
2. Fall:
Haben beide Methoden die gleiche Signatur, so hat Z eine Methode mit
dieser Signatur.
3. Fall:
Haben beide Methoden den gleichen Namen und die gleiche
Parameterliste, aber unterschiedliche Rückgabetypen, so gibt es einen
unlösbaren Konflikt.
© Klaus Hinrichs
Informatik I – Java
5-184
Interfaces
• Interfaces haben keine ausgezeichnete Wurzel, von der alle Interfaces
erben (anders als Klassen, die alle von Object erben). Dennoch
können Ausdrücke eines beliebigen Interface-Typen an eine Referenz
auf ein Objekt der Klasse Object zugewiesen werden, denn ein
Objekt, das ein Interface implementiert, ist eben irgendein Objekt und
damit auch vom Typ Object.
• Interfaces unterstützen Trennung von Deklaration und
Implementierung.
• Interfaces erlauben eine Art Mehrfachvererbung. Eine Klasse kann nur
von einer anderen Klasse erben, selbst wenn die vererbende Klasse
nur abstrakte Methoden hat.
© Klaus Hinrichs
Informatik I – Java
5-185
Interfaces
• Eine abstrakte Klasse kann teilweise implementiert sein, sie kann über
protected Attribute, static Methoden usw. verfügen. Interfaces
können nur public Konstanten und Methoden ohne Realisierungen
beinhalten.
• Tip: Jede grundlegende Klasse, von der geerbt wird, sollte die
Implementierung eines Interface sein! Nur dann können andere
Klassen (die schon erben) von der allgemeinen Festlegung profitieren.
© Klaus Hinrichs
Informatik I – Java
5-186
5.8 Programmierkonventionen und Dokumentation
• Warum Programmierkonventionen
(Code Conventions)?
– Nur wenig Software wird ausschließlich vom ursprünglichen Autor
gewartet.
– Programmierkonventionen erleichtern Lesbarkeit und
Verständlichkeit.
– Selbst geringe Verbesserungen der Wartbarkeit rechtfertigen
Anstrengungen in der Entwicklung.
© Klaus Hinrichs
Informatik I – Java
5-187
Ein Ausblick in die Wartung
• Folgende Aufgaben können in der Wartung unterschieden werden:
– Beseitigung von Fehlern, die den Software-Einsatz behindern:
- echte Entwicklungsfehler
- in der Wartung eingefügte Fehler
- Sicherstellung von nicht vorhergesehenen
Anforderungen nach Auslieferung
– Anpassung an Änderungen der Umweltbedingungen (Hardware,
Fremdsoftware, Organisation)
- Jahr 2000 / EURO
- gesetzliche Änderungen
- neue Basissysteme
– Erfüllung neuer Anforderungen
(Appetit kommt beim Essen!)
© Klaus Hinrichs
Informatik I – Java
5-188
Lehman's laws
• Lehman's Law of Uncertainty and Lehman's Law of Increasing
Software Entropy bedeuten, daß Änderungen während und nach der
Entwicklung unvermeidlich sind.
– Law of Uncertainty: Software ändert sich während ihres ganzen
Lebenszyklus. Genauere Angaben zum Gegenstand der
Änderungen sind nicht vorhersehbar.
– Law of Increasing Software Entropy: Änderungen einer Software
machen ihre Struktur in der Regel unverständlicher. Die innere
Struktur einer Software geht mit fortschreitender SoftwareLebenszeit verloren.
© Klaus Hinrichs
Informatik I – Java
5-189
Programmierkonventionen
• Das Verhältnis von Entwicklungsaufwand zu Wartungsaufwand wird
in der Literatur in einem Bereich zwischen 1: 4 und 1: 2 angegeben
! 20 - 33% der gesamten Kosten entfallen auf die Entwicklung und
67 - 80% auf die Wartung!
• Deshalb:
Programmierkonventionen als eine Maßnahme der Verbesserung
der Wartbarkeit! Andere Maßnahmen:
Dokumentation der Ergebnisse von OOA und OOD, Verzicht auf
Trick-Programmierung.
• Wie sollen Programmierkonventionen eingesetzt werden?
– Die offiziellen Konventionen sollten als Basis dienen.
– Sie funktionieren nur, wenn sie von jedem eingehalten werden.
– Es kann projektspezifische Erweiterungen geben.
© Klaus Hinrichs
Informatik I – Java
5-190
Datei-Organisation
• Keine Dateien mit mehr als 2000 Zeilen
• Abschnitte sollten durch Leerzeilen getrennt werden
• Jede Datei sollte nur eine öffentliche Klasse bzw. ein öffentliches
Interface besitzen
• Öffentliche Klasse / Interface ist am Dateianfang zu finden
• Datei hat vorgegebene Aufteilung:
– Anfangskommentare
– Package und Import-Statements
– Klassen- und Interface-Deklarationen
© Klaus Hinrichs
Informatik I – Java
5-191
Ordnung innerhalb einer Datei
• Reihenfolge in einer Datei:
Anfangskommentare in C- Format:
/*
* Klassenname
*
* Versionsinformation
*
* Copyright-Vermerk
*/
Package- und Import-Statements
package java.awt;
import java.awt.peer.CanvasPeer;
© Klaus Hinrichs
Informatik I – Java
5-192
Ordnung innerhalb einer Datei
• Klassen- und Interfacedeklarationen in vorgegebener Reihenfolge:
– Klassen / Interface-Kommentar (/** … */)
– class oder interface Definition
– Klassen / Interface-Implementierungskommentar, falls nötig
(/*...*/)
– Klassenvariablendeklarationen (static)
– Instanzvariablendeklarationen
– Konstruktoren
– Methoden (geordnet, z. B. sollten öffentliche Klassen nicht
zwischen privaten stehen)
© Klaus Hinrichs
Informatik I – Java
5-193
Formatierung
• Es werden 4 Zeichen eingerückt.
• Eine Zeile ist maximal 80 Zeichen breit.
• Regeln für Zeilenumbrüche:
– Umbruch auf höchstmöglicher Ebene
– Umbruch vor Operatoren und nach Kommata
– Gleiche Hierarchieebenen sollen möglichst in folgender Zeile
untereinanderstehen, falls nicht möglich, ist 8 Zeichen
einzurücken:
var = funktion1(Ausdruck1,
funktion2(Ausdruck2,
Ausdruck3));
© Klaus Hinrichs
Informatik I – Java
5-194
Kommentare
• Block-Kommentare mit führendem * in folgender Form:
/*
* Dies ist ein Kommentar.
*/
• Einzeilenkommentare kommen vor dem entsprechenden
Programmcode mit zugehöriger Einrückung.
Vor dem Kommentar steht eine Leerzeile
if (Bedingung) {
/* Bedingung wird ausgewertet */
...
}
• Zeilenendekommentare (//) am Ende der Zeile sollten genügend
eingerückt sein. Sie werden nicht für mehrzeilige Kommentare
benutzt, es sei denn, Programmtext wird auskommentiert:
if (personImHaus == TRUE) {
return Zimmernummer; // Raum im Haus
} else {
return Adresse;
// Privatadresse
}
Informatik I – Java
© Klaus Hinrichs
5-195
Deklarationen
• Es sollte möglichst nur eine Deklaration pro Zeile erfolgen:
String name;
String straße;
// Vor- und Nachname
// Straße mit Hausnummer
und nicht
String name, straße;
• Auf keinen Fall dürfen Deklarationen unterschiedlichen Typs oder
Methoden- und Attributdeklarationen in einer Zeile stehen:
long kundennummer, getKundennummer();
String name, namensliste[];
• Deklarationen sollten immer am Anfang eines Blocks stehen.
• Mit Variablendeklarationen sollte nicht bis zur ersten Benutzung
gewartet werden.
© Klaus Hinrichs
Informatik I – Java
5-196
Deklarationen
• Lokale Variablen sollten, sofern möglich, bei Deklaration auch
initialisiert werden.
• Überdeckungen von Variablen einer höheren Ebene sollten
vermieden werden:
int zähler;
...
void funktion() {
if (Bedingung) {
int zähler;
}
}
// Vermeiden!
© Klaus Hinrichs
Informatik I – Java
5-197
Anweisungen
• Eine Zeile sollte nur einen Ausdruck enthalten:
argv++; argc++;
// Vermeiden!
• In Blöcken sollten öffnende Klammern am Zeilenende stehen.
• Struktur von if- und if-else- Anweisungen:
if (Bedingung) {
Anweisungen;
}
if (Bedingung) {
Anweisungen;
} else {
Anweisungen;
}
if (Bedingung) {
Anweisungen;
} else if (Bedingung) {
Anweisungen;
} else if (Bedingung) {
Anweisungen;
}
© Klaus Hinrichs
Informatik I – Java
5-198
Namenskonventionen
• Klassennamen:
Substantive, große Anfangsbuchstaben, ganze Worte, innere Worte
beginnen mit Großbuchstaben
class Datum;
class KundenListe;
• Interfacenamen:
Analog zu Klassennamen
• Methodennamen:
Verben, klein geschrieben, innere Worte beginnen mit Großbuchstaben
int gibKundenListe();
© Klaus Hinrichs
Informatik I – Java
5-199
Namenskonventionen
• Variablen / Attribute
– am Wortanfang klein geschrieben, innere Worte beginnen mit
Großbuchstaben
– Namen sollen selbsterklärend sein
Datum meinGeburtsDatum = new Datum(" 1.1.1904");
– Temporäre Variablen dürfen mit einem Buchstaben benannt
werden, hierbei gilt:
i , j , k , m und n werden für Integerzahlen benutzt, c , d und e für
Zeichen
• Konstanten werden komplett groß geschrieben, Worte durch "_"
voneinander getrennt
final int MINIMALE_BREITE = 10;
© Klaus Hinrichs
Informatik I – Java
5-200
Sonstige Konventionen
• Klassen und Methoden sollten so privat wie möglich deklariert
werden
• Konstanten sollten über Namen in Programmcode eingebaut werden
(bis auf bedeutungslose, wie -1, 0 , 1)
• Mehrfachzuweisungen sollten vermieden werden
a = b = c;
// Vermeiden!
• Klammerungen können selten benutzte Operatorprioritäten
verdeutlichen.
Informatik I – Java
© Klaus Hinrichs
5-201
Dokumentation
• Es gibt 3 Sorten von Kommentaren:
// Rest der Zeile wird auskommentiert
/*
* Ein gesamter Abschnitt wird kommentiert,
* Achtung: Schachtelung von Kommentaren ist
* nicht möglich
*/
/**
* Eine Klasse oder Methode wird kommentiert,
* aus diesem Kommentar lassen sich automatisch
* HTML- Dokumentationen erstellen
*/
• Automatische Dokumentation geschieht mit Hilfe des Tools javadoc
von JDK.
• Aufruf:
© Klaus Hinrichs
javadoc *.java
Informatik I – Java
5-202
javadoc-Dokumentation
• /** */ - wird vor Klassen- und Interface- Deklarationen sowie vor
Methoden, Konstruktoren und Attributdeklarationen berücksichtigt.
• Kommentar wird in HTML-Dokumentation von javadoc aufgenommen.
! HTML-Tags im Kommentar sind erlaubt
• /** ist Kommentaranfang und */ ist Kommentarende.
• Innerhalb des Kommentars wird ein * am Zeilenanfang ignoriert.
• Erster Teil des Kommentars ist ein gesonderter
Zusammenfassungssatz (evtl. auch mehrere), der letzte Punkt ist die
Endmarkierung.
© Klaus Hinrichs
Informatik I – Java
5-203
javadoc-Dokumentation
• Durch @-Zeichen innerhalb des Kommentars werden Tags eingefügt,
um automatische Querreferenzen zu erzeugen.
• @see-Tag erzeugt allgemeine Querreferenz
– Referenz zu anderer Klasse:
@see java.io.InputStream
@see String
– Referenz zu einer Methode einer Klasse:
@see String#equals
– Referenz zu anderer HTML- Datei:
@see <a href="spec.html"> Java Spec</a>
• @author-Tag um Autor zu kennzeichnen
@author Albert Einstein
@author Albert Einstein, Max Born
• @version-Tag kennzeichnet Version
@version 1.01beta
© Klaus Hinrichs
Informatik I – Java
5-204
javadoc-Dokumentation
• @param-Tag
– Erklärung für Parameter in Methoden und
Konstruktorendeklarationen:
@param Name Name der Person muß übergeben werden
• @return-Tag
– Bedeutung des Rückgabeparameters
• @exception-Tag
– Erklärung von Ausnahmen in Methoden und
Konstruktordeklarationen:
@exception IndexOutOfBoundsException
Die Feldgrenze wird überschritten
• @deprecated-Tag (ab JDK 1.1)
– Kennzeichnung veralteter Methoden
© Klaus Hinrichs
Informatik I – Java
5-205
5.9 Packages und Exceptions
• Informatik II, Sommersemester 2006
© Klaus Hinrichs
Informatik I – Java
5-206
Ausblick
In den Semesterferien:
Java
programmieren, programmieren,
programmieren,
…
© Klaus Hinrichs
Informatik I – Java
5-207