Einführung in die Programmierung - Homepage von Peter Ziesche

Einführung in die Programmierung
Sommersemester 2005 – 2. Semester
Vererbung – Beispiele zur Übung vom 04.06.2005
Angenommen, es soll eine Anwendung für eine Universitäts-Bibliothek entwickelt werden. Als
Ausleiher für Bücher und Zeitschriften kommen Studenten und Angestellte der Universität in
Frage. Sie werden durch zwei Klassen Student und Angestellter modelliert. Beide
Klassen haben gemeinsame Eigenschaften wie z.B. Name, Vorname, Adresse, Telefon und
E-Mail. Darüber hinaus hat jede Klasse individuelle Attribute: ein Student hat eine Matrikel-
Nummer und die Anzahl seiner Semester, ein Angestellter hat eine dienstliche Telefon-Nr.
In der objektorientierten Programmierung können die Gemeinsamkeiten beider Klassen in einer
Oberklasse Ausleiher zusammengefasst werden. Die Klassen Student und
Angestellter erben von der Klasse Ausleiher. Ein Vorteil der Vererbung ist, dass die
gemeinsamen Eigenschaften nur einmal in der Oberklasse Ausleiher definiert werden
müssen. Die erbenden Klassen definieren nur die individuellen Eigenschaften.
In Java wird das Erben von einer Oberklasse mit das Schlüsselwort extends formuliert. Die
drei Klassen für die Uni-Bibliothek sehen in Java wie folgt aus (es werden nicht alle oben
genannten Eigenschaften definiert):
public class Ausleiher {
private String name;
private String telefon;
}
public String getName() {
return name;
}
public void setName( String value ) {
vorname = value;
}
public String getTelefon() {
return telefon;
}
public void setTelefon( String value ) {
telefon = value;
}
public class Student extends Ausleiher {
private String matrikelNr;
public String getMatrikelNr() {
return matrikelNr;
}
public void setMatrikelNr( String value ) {
matrikelNr = value;
Fachhochschule Südwestfalen
Peter Ziesche
E-Mail: mail@peterziesche.de

}
}
public class Angestellter extends Ausleiher {
private String dienstNummer;
}
public String getDienstNummer() {
return dienstNummer;
}
public void setDienstNummer( String value ) {
dienstNummer = value;
}
Von allen drei Klassen können Objekte erzeugt werden. Eine Referenz vom Typ Ausleiher
kann auf Objekte aller drei Klassen zeigen. Die folgenden Codezeilen sind also korrekt:
Student s1 = new Student();
Angestellter a1 = new Angestellter();
Ausleiher ausleiher1 = s1; //ein Student ist ein Ausleiher
Ausleiher ausleiher2 = a1; //ein Angestellter ist ein Ausleiher
Über die Referenz ausleiher1 kann nur auf die Eigenschaften und Methoden des
Student-Objekts zugegriffen werden, die in der Oberklasse Ausleiher definiert sind. Es
gilt nämlich: der Typ der Referenz legt fest, auf welche Eigenschaften und Methoden eines
Objekts zugegriffen werden kann, unabhängig davon, von welcher Klasse das Objekt tatsächlich
ist. Für die oben erzeugten Objekte gilt:
ausleiher1.setName( "Meier" ); //korrekt;
ausleiher1.setMatrikelNummer( "3034713" ); //Fehler
ausleiher2.setDienstNummer( "456-3248" ); //Fehler
Der Vorteil von Vererbung wird deutlich, wenn man folgende Funktion implementiert: Es soll
eine Liste der Ausleiher gedruckt werden, bei denen Bücher oder Zeitschriften überfällig sind.
Die Methode könnte so aussehen:
public void druckeMahnliste( ArrayList liste ) {
int i=0;
while( i < liste.size()) {
Ausleiher einAusleiher = (Ausleiher) liste.get(i);
System.out.println( einAusleiher.getName() );
}
}
Für den Druck der Liste ist es unerheblich, ob es sich bei den Listenelementen um Studenten
oder Angestellte handelt. Es wird lediglich der Name ausgedruckt, eine Eigenschaft der
Oberklasse Ausleiher. Natürlich muss die Liste irgendwo anders im Programm mit Objekten
gefüllt werden. Innerhalb der Methode druckeMahnliste() ist die genaue Klasse der
Elemente nicht wichtig.
Soll später einmal eine weitere Sorte von Ausleihern hinzugefügt werden, z.B. Professoren,
braucht die Methode druckeMahnliste() nicht verändert zu werden. Sie wird dann
automatisch auch säumige Professoren ausdrucken können, wenn auch die Klasse Professor
von Ausleiher erbt.

Polymorphismus
Wenn die Liste der säumigen Ausleiher auch die Telefon-Nr. ausdrucken soll, ergibt sich ein
Problem. Zwar hat ein Angestellter auch eine private Telefon-Nr. (ein Attribut der Klasse
Ausleiher), für einen Mitarbeiter der Bibliothek ist es aber wahrscheinlich einfacher, den
Angestellten an seinem Arbeitsplatz anzurufen und um Rückgabe der entliehenen Bücher zu
bitten. Bei Angestellten sollte also die Dienst-Nr. ausgedruckt werden, bei Studenten die
Privat-Nr.
Es wäre schlechter Stil, wenn in der Methode druckeMahnliste() abgefragt würde, ob das
Listen-Element ein Student- oder ein Angestellter-Objekt ist. Damit wäre die Methode
wieder von der konkreten Klasse eines Objekts abhängig. Beim späteren hinzufügen der Klasse
Professor müsste druckeMahnliste() angepasst werden.
In der objektorientierten Programmierung benutzt man stattdessen die Möglichkeit, Methoden
einer Oberklasse in einer Unterklasse zu redefinieren (statt redefinieren wird häufig auch der
Begriff überschreiben verwendet). In der Klasse Ausleiher liefert die Methode
getTelefon() die Privat-Nr des Ausleihers zurück. Die Klasse Angestellter kann diese
Methode so redefinieren, dass stattdessen die Dienst-Nr. zurückgeliefert wird:
public class Angestellter extends Ausleiher {
private String dienstNummer;
}
public String getTelefon() {
return dienstNummer;
}
public void setTelefon( String value ) {
dienstNummer = value;
}
public String getPrivatNummer() {
return telefon; //Attribut von Ausleiher
}
public void setPrivatNummer( String value ) {
telefon = value;
}
Die von Ausleiher geerbten Methoden getTelefon() und setTelefon() werden also
in der Klasse Angestellter so verändert, dass sie die dienstliche Nummer zurückliefern
oder setzen. Die Klasse Angestellter erhält zusätzlich noch die Methoden
getPrivatNummer() und setPrivatNummer(), mit denen gezielt auf das geerbte
Attribut zugegriffen werden kann.
Die Methode druckeMahnliste() kann nahezu unverändert bleiben:
public void druckeMahnliste( ArrayList liste ) {
int i=0;
while( i < liste.size()) {
Ausleiher einAusleiher = (Ausleiher) liste.get(i);
System.out.println( einAusleiher.getName() +
" " + einAusleiher.getTelefon());
}
}

Durch die Redefinition der Methode getTelefon() in der Klasse Angestellter wird
jetzt bei Studenten die Private-Nr. und bei Angestellten die Dienst-Nr. ausgedruckt. Die
virtuelle Maschine von Java kümmert sich automatisch im Hintergrund darum, dass bei
Student-Objekten getTelefon() von Ausleiher und bei Angestellter-Objekten
getTelefon() von Angestellter aufgerufen wird. Diese automatische Auswahl von
Methoden wird als Polymorphismus bezeichnet.
Object
Wenn eine Java-Klasse von keiner anderen Klasse erbt, also kein extends angibt, fügt der
Java-Compiler bei der Übersetzung der .java-Datei automatisch extends Object ein. Jede
Klasse erbt also direkt oder indirekt immer von Object.
Dies hat zur Folge, dass Referenzen vom Typ Object auf beliebige Objekte zeigen können
(man mache sich dies eindringlich klar). Die folgenden Zeilen sind also korrekt:
Angestellter an = new Angestellter();
ArrayList al = new ArrayList();
String s = "Hallo TBW";
Object objekt1 = an;
Object objekt2 = al;
Object objekt3 = s;
Benutzt wird dies vor allem in Container-Klassen, wie z.B. ArrayList. Da in der Liste
beliebige Objekte gespeichert werden sollen, speichert eine ArrayList einfach Referenzen
vom Typ Object und kann damit auf jedes Java-Objekt verweisen.
Schnittstellen
In der dritten Übung wurden Sortier-Algorithmen entwickelt. Sie waren in der Lage, eine Liste
von Büchern aufsteigend nach Preisen zu sortieren. Man betrachte nun den folgenden Sortier-
Algorithmus (Bubblesort) und achte darauf, an welchen Stellen der Algorithmus davon
abhängig ist, dass Bücher nach Preisen sortiert werden sollen. Diese Stellen sind fett gedruckt.
public static void sortiere(ArrayList liste) {
int j = liste.size()-1;
while( j>0) {
int i=0;
while( i < j) {
Buch b1 = (Buch) liste.get(i);
Buch b2 = (Buch) liste.get(i+1);
}
if(b1.Preis > b2.Preis) {
//swappen
//Element i mit Element i+1 tauschen
liste.set( i, b2);
liste.set( i+1, b1);
}
i++;
}
j--;
}

Abgesehen von den drei markierten Stellen ist der Algorithmus unabhängig davon, dass Bücher
nach Preisen sortiert werden sollen. Der Rest des Algorithmus bliebe unverändert, wenn z.B.
Studenten nach Matrikel-Nr. sortiert werden sollten.
Um die Abhängigkeit von der Klasse Buch zu entfernen, braucht nur Buch durch Object
ersetzt zu werden. Durch die Verwendung von Object-Referenzen kann der Algorithmus mit
beliebigen Objekten umgehen (siehe oben).
Allerdings ist es dann nicht mehr ohne weiteres möglich, die Preise zweier Bücher miteinander
zu vergleichen, denn Object hat keine Eigenschaft Preis und der Typ der Referenz legt fest,
auf welche Eigenschaften und Methoden zugegriffen werden kann. Zur Lösung dieses Problems
bietet Java Schnittstellen an. Schnittstellen sind ähnliche Konstrukte wie Klassen, enthalten aber
nur Methoden-Definitionen ohne Implementierung. Für den Sortier-Algorithmus muss eine
Schnittstelle definiert werden, über die zwei Objekt miteinander verglichen werden können.
public interfache Vergleicher {
}
//-1 wenn objekt1 kleiner als objekt2 ist
// 0 wenn beide Objekte gleich sind
//+1 wenn objekt 1 größer als objekt2 ist
int vergleiche( Object objekt1, Object objekt2 );
Für den Preisvergleich zwischen zwei Büchern wird eine Klasse geschrieben, die
Vergleicher implementiert:
public class BuchPreisVergleicher implements Vergleicher {
public int vergleiche( Object objekt1, Object objekt2 ) {
Buch buch1 = (Buch) objekt1;
Buch buch2 = (Buch) objekt2;
if( buch1.Preis < buch2.Preis ) {
return -1;
}
else if( buch1.Preis > buch2.Preis ) {
return 1;
}
return 0;
}
}
Die Klasse BuchPreisVergleicher stellt für die in der Schnittstelle definierte Methode
vergleiche() eine Implementierung zur Verfügung, die zwei Bücher bezüglich ihrer Preise
vergleicht und das billigere als kleineres zurückliefert. Eine andere Implementierung von
Vergleicher könnte Bücher nach Titel oder Autor sortieren oder Objekte einer ganz anderen
Klasse miteinander vergleichen. Um z.B. Studenten nach Matrikel-Nr. (siehe oben) absteigend
zu sortieren benötigt man folgende Klasse, mit der Sortier-Algorithmus unverändert auch zu
Sortieren von Student-Objekten verwendet werden kann:
public class StudentVergleicher implements Vergleicher {
public int vergleiche( Object objekt1, Object objekt2 ) {
Student s1 = (Student) objekt1;
Student s2 = (Student) objekt2;
return s1.getMatrikelnr().compareTo( s2.getMatrikelNr());
}
}

Die Methode compareTo() ist in der Klasse String definiert. Sie vergleicht zwei Strings
miteinander und liefert den als kleineren zurück, der bei alphabetischer Sortierung als erster
kommt.
Der Sortier-Algorithmus wird so umgeschrieben, dass er als Parameter neben der Liste auch
eine Referenz auf ein Vergleicher-Objekt erhält. Dieses Objekt benutzt der Algorithmus,
um das kleinere von zwei Objekten zu ermitteln. Es spielt dann keine Rolle mehr, ob Bücher,
Studenten oder andere Objekte sortiert werden sollen. Man benötigt nur noch einen Sortier-
Algorithmus für alle möglichen Sortierungen.
public static void sortiere(ArrayList liste, Vergleicher v) {
int j = liste.size()-1;
while( j>0) {
int i=0;
while( i < j) {
Object o1 = liste.get(i);
Object o2 = liste.get(i+1);
}
if(v.vergleiche( o1, o2) == -1) {
//swappen
//Element i mit Element i+1 tauschen
liste.set( i, b2);
liste.set( i+1, b1);
}
i++;
}
j--;
}
Schnittstellen werden im Java-API häufig eingesetzt, um Standard-Klassen ein spezifisches
Verhalten zu verleihen. Zum Beispiel gibt es eine Klasse MouseListener. Sie definiert
Methoden, mit denen auf einen Tastendruck der Maus reagiert werden kann. Eine konkrete
Anwendung enthält eine Klasse, die MouseListener implementiert. Ein Fenster, ein Objekt
der Java-API-Klasse Window, ruft bei jedem Mausklick die Methoden der Schnittstelle auf.
Eine Anwendung kann dadurch individuell auf Mausklicks reagieren, ohne eine eigene Fenster-
Klasse schreiben zu müssen.