Quelltext der Seite Kapitel 9: Vererbung

Die Vererbung ist eines der grundlegenden Konzepte der Objektorientierung. Sie dient dazu, aufbauend auf bereits existierenden Klassen neue zu schaffen, wobei die Beziehung zwischen ursprünglicher und neuer Klasse - anders als bei einer Assoziation -  dauerhaft ist. Eine neue Klasse kann dabei eine Erweiterung oder eine Einschränkung der ursprünglichen Klasse sein.<br/> Die vererbende Klasse wird meist '''Oberklasse''' (oder auch Superklasse) genannt, die erbende '''Unterklasse'''. 


'''Problemstellung'''

Ein Autohändler, der sowohl mit Neu- als auch mit Gebrauchtwagen handelt, will die Fahrzeuge in einer Datenbank erfassen, wobei er die beiden Typen möglichst effizient und unabhängig voneinander abspeichern möchte. Eine Modellierung könnte zuerst einmal folgendermaßen aussehen:

[[Datei:vererbung1.JPG]]

Was hier sehr schnell auffallen dürfte, ist die Tatsache, dass die Darstellungen weitgehend übereinstimmen und der Gebrauchtwagen nur weitere Attribute enthält, die beim Neuwagen von geringem Interesse sind. Das Konzept der Vererbung ermöglicht es nun, die Klasse ''Gebrauchtwagen'' als Unterklasse der Klasse ''Auto'' zu modellieren. Dies bedeutet, dass ein Objekt alle Attribute und Methoden der Oberklasse erbt und noch weitere Attribute und Methoden erhält. In der Unified Modeling Language (UML) wird eine Vererbungsbeziehung durch einen Pfeil mit einer dreieckigen Spitze dargestellt, der von der Unterklasse zur Oberklasse zeigt. Geerbte Attribute und Methoden werden in der Darstellung der Unterklasse nicht wiederholt.

[[Datei:vererbung2.JPG]]


'''Spezialisierung und Generalisierung'''

Spezialisierung und Generalisierung sind zwei Sichtweisen des Vererbungskonzepts. Bilden wir eine neue Klasse, deren Instanzen eine Teilmenge der Instanzen der Oberklasse darstellen, sprechen wir bei der Bildung der Unterklasse von einer '''Spezialisierung''' (Konkretisierung). Fassen wir dagegen Attribute und Methoden mehrerer ähnlicher Klassen zu einer neuen Klasse zusammen, sprechen wir von einer '''Generalisierung''' (Abstraktion).

<div style="margin-left:100px; margin-top:30px; margin-bottom:30px">
[[Datei:vererbung3.JPG]]
</div>

'''Klassenhierarchien'''

In einer Klassenhierarchie werden statische Beziehungen zwischen den Klassen dargestellt. Die Darstellung ähnelt einem Stammbaum, wie wir ihn in der 6.Klasse kennengelernt haben. Die höher liegenden Klassen vererben bei Bedarf an die darunterliegenden Klassen welche wieder an Klassen unter ihnen vererben.

<u>'''Beispiel:'''</u>

Die Schulfamilie hat verschiedene Mitglieder. Es gibt Schüler, Lehrer und Eltern, die alle nicht nur Mitglieder der Schulfamilie (MdS) sind, sondern sie alle sind Personen. Alle Mitglieder der Schulfamilie erben von der Klasse ''Person'' die Attribute ''name'' und ''geburtsdatum''. Lehrer und Schüler haben dagegen weitere recht unterschiedliche Attribute. Mitglieder der Schulleitung sind zwar auch Lehrer, haben aber noch weitere Attribute, was eine Spezialisierung der Klasse Lehrer nahelegt.

<div style="margin-left:100px; margin-top:30px; margin-bottom:30px">
[[Datei:vererbung4.JPG]]
</div>

<big>[[Aufgaben 9.1.]]</big>



'''Umsetzung in Java'''

In Java können Klassenhierarchien nur durch Spezialisierung gebildet werden: Unterklasse erweitert (''extends'') Oberklasse. Dies spiegelt sich in der Syntax wieder - die Klassendefinition der Unterklasse weist auf ihren Status als Erweiterung der Oberklasse hin:

<pre>
public class <Name der Unterklasse> extends <Name der Oberklasse>
</pre>

<u>Hinweise:</u>

* Vererbung bedeutet, dass die Unterklasse alle Attribute und Methoden von der Oberklasse übernimmt.
* Es werden keine Konstruktoren vererbt!
* Unter- und Oberklasse bieten Konstruktoren an.
* Die Unterklasse kümmert sich in ihrem Konstruktor nur um die Attribute, die in der Unterklasse deﬁniert sind.
* Damit auch die Datenfelder der Oberklasse korrekt initialisiert werden,rufen wir den Konstruktor der Oberklasse auf.
* Der Aufruf des Konstruktors der Oberklasse erfolgt mit dem Schlüsselwort '''super'''.
* Dieser Aufruf muss stets die erste Anweisung in einem Konstruktor der Unterklasse sein! Ansonsten fügt der Compiler den Aufruf eines parameterlosen Konstruktors für die Oberklasse ein.

Als Beispiel soll nun die (teilweise) Implementierung der Klassenhierarchie aus dem Schulfamilie-Beispiel dienen:


<syntaxhighlight lang="java">

public class Person {
//Attribute
private String name;
private String geburtsdatum

//Konstruktor
public person(String name, String geburtsdatum){
this.name=name;
this.geburtsdatum = geburtsdatum;
}

//Getter- und Setter-Methoden
public String getName(){
return name;
}

public String getGeburtsdatum(){
return geburtsdatum;
}

public void setName(String n){
name=n;
}

public void setGeburtsdatum(String g){
geburtsdatum = g;
}
}
</syntaxhighlight>


<syntaxhighlight lang="java">
public class MdS extends Person{
//weitere Attribute für Mitglieder der Schulfamilie
public String telefonnummer;

//Konstruktor
public MdS(String name, String geburtsdatum, String telefonnummer){
//Aufruf des Konstruktors der Oberklasse
super(name, geburtsdatum);
//Initialisierung der weiteren Variablen
this.telefonnummer=telefonnummer;
}

//weitere Getter- und Setter-Methoden
public String getTelefonnummer(){
return telefonnummer;
}

public void setTelefonnummer(String t){
telefonnummer=t;
}
}
</syntaxhighlight>


<syntaxhighlight lang="java">
public class Lehrer extends MdS{
//weitere Attribute
private String pkz;
...

//Konstruktor
public Lehrer(String name, String geburtsdatum, String telefonnummer, String pkz){
//Aufruf des Konstruktors der Oberklasse
super(name, geburtsdatum, telefonnummer);
//Initialisierung der weiteren Variablen
this.pkz = pkz;
}

//Getter-, Setter- und andere Methoden
...

public void pruefen (Schueler s){ ... }

public void verweisErteilen /Schueler s) { ... }

...
}
</syntaxhighlight>


<syntaxhighlight lang="java">
public class Schueler extends MdS {
//weitere Attribute
private String schueler-ID;

//Konstruktor
public Schueler((String name, String geburtsdatum, String telefonnummer, String schueler-ID){
//Aufruf des Konstruktors der Oberklasse
super(name, geburtsdatum, telefonnummer);
//Initialisierung der weiteren Variablen
this.schueler-ID = schueler-ID;
}

//Getter-, Setter- und andere Methoden
...

public void hausaufgabeMachen(){ ... }

public void rechenschaftsablage(){ ... }

}

</syntaxhighlight>


<u>Zur Vertiefung: </u>

<div style="margin-left:100px; margin-top:30px; margin-bottom:30px">
{{#ev:youtube|Zf-aL6gCPxQ}}
</div>


<big>[[Aufgaben 9.2.]]</big>


'''Polymorphie'''

In der Lösung von Aufgabe 9.2.1 sind wir auf das Phänomen gestoßen, dass der ''Filialleiter'' das Gehalt eines ''Auszubildenden'' erhöhen konnte, obwohl die entsprechende Methode einen Parameterwert vom Typ ''Mitarbeiter'' verlangt hat. Dies ist dem Konzept der Polymorphie (griech. Vielgestaltigkeit) geschuldet. Dies bedeutet vereinfacht: '''Alles, was den deklarierten Typ der Referenzvariable ''erweitert'', kann der Referenzvariable ''zugewiesen'' werden.'''


<syntaxhighlight lang="java">
public class Kfz {

public KfZ() { ... }

public void info(){
System.out.println("Ich bin ein Kraftfahrzeug.");
}
}
</syntaxhighlight>


<syntaxhighlight lang="java">
public class Lkw extends Kfz {

public Lkw() { ... }

public void info(){
System.out.println("Ich bin ein Lastkraftwagen.");
}
}
</syntaxhighlight>


<syntaxhighlight lang="java">
public class Pkw extends Kfz {

public Pkw() { ... }

public void info(){
System.out.println("Ich bin ein Personenkraftwagen.");
}
}
</syntaxhighlight>


<syntaxhighlight lang="java">
public class Test(){

public Test() { 
Kfz k = new Kfz();
Kfz l = new Lkw();
Kfz p = new Pkw();

Lkw l2 = new Lkw();
Pkw p2 = new Pkw();

k.info();
l.info();
p.info();

l2.info();
p2.info()
 }
}
</syntaxhighlight>


Die Ausgabe sieht nun folgendermaßen aus:

<pre>
Ich bin ein Kraftfahrzeug.
Ich bin ein Lastkraftwagen.
Ich bin ein Personenkraftwagen.
Ich bin ein Lastkraftwagen.
Ich bin ein Personenkraftwagen.
</pre>

Auch wenn im zweiten und dritten Fall der Variable vom Typ ''Kfz'' eine Instanz einer Unterklasse zugeordnet wird, greift das Programm auf die entsprechende Methode ''info()'' der Unterklassen zu.


<u>Zur Vertiefung: </u>

<div style="margin-left:100px; margin-top:30px; margin-bottom:30px">
{{#ev:youtube|w4U-MkcLunU}}
</div>



'''Überschreiben von Methoden'''

Eine Unterklasse kann durch Vererbung die sichtbaren Eigenschaften ihrer Oberklasse erben. Sie kann nun wiederum Methoden hinzufügen. Besitzt eine Unterklasse eine Methode mit dem gleichen Methodennamen und der exakten Parameterliste (also der gleichen ''Signatur'') wie schon die Oberklasse, so überschreibt die Unterklasse die Methode der Oberklasse. Implementiert die Unterklasse die Methode neu, so sagt sie auf diese Weise: ''"Ich will es aber anders machen!."'' (siehe Methode ''info()'' im obigen Beispiel) Die überschreibende Methode der Unterklasse kann demnach den Programmcode spezialisieren und Eigenschaften nutzen, die in der Oberklasse nicht bekannt sind. Die überschriebene Methode der Oberklasse ist dann erst einmal aus dem Rennen, und ein Methodenaufruf auf einem Objekt der Unterklasse würde die überschreibende Methode aufrufen.


<u>Zur Vertiefung: </u>

<div style="margin-left:100px; margin-top:30px; margin-bottom:30px">
{{#ev:youtube|n-3rn0xXBgY}}
</div>


<big>[[Aufgaben 9.3.]]</big>


'''Die Sichtbarkeit ''protected'''''

Eine Unterklasse erbt alle sichtbaren Eigenschaften, d.h. alle Eigenschaften deren Zugriffsrecht ''public'' ist. Die Vererbung kann durch ''private'' eingeschränkt werden, dann sieht keine andere Klasse die Eigenschaften, weder fremde noch Unterklassen. Daneben kommt nun noch eine weitere Sichtbarkeit hinzu: '''''protected'''''.  '''''protected'''''-Eigenschaften werden an alle Unterklassen vererbt.


'''Abstrakte Klassen'''

In Java ist es möglich, abstrakte Methoden zu definieren. Im Gegensatz zu konkreten Methoden enthalten sie nur die Deklaration des Methodenkopfes, aber keine Implementierung des Methodenrumpfes. Syntaktisch unterscheiden sich abstrakte Methoden dadurch, dass anstelle der geschweiften Klammern mit den auszuführenden Anweisungen lediglich ein Semikolon steht. Zusätzlich wird die Definition mit dem Attribut '''''abstract''''' versehen. Abstrakte Methoden können nicht aufgerufen werden. Sie definieren nur eine Schnittstelle, die durch Überschreiben in einer abgeleiteten Klasse implementiert werden kann. Es ist sozusagen eine Aufforderung an jede abgeleitete Klasse, diese abstrakten Methoden zu implementieren und damit konkret zu machen. Tut sie dies nicht, wird sie selbst als abstrakt angesehen und muss ebenfalls mit dem Schlüsselwort '''''abstract''''' versehen werden. Von abstrakten Klassen können keine Instanzen gebildet werden, da sie Methoden enthalten, die nicht implementiert wurden. Statt dessen werden abstrakte Klassen abgeleitet, und in der abgeleiteten Klasse werden eine oder mehrere der abstrakten Methoden implementiert. Eine abstrakte Klasse wird konkret, wenn alle ihre Methoden implementiert sind. Die Konkretisierung kann dabei auch schrittweise über mehrere Vererbungsstufen erfolgen.