Vererbung: Unterschied zwischen den Versionen

Aus ComeniusWiki
Wechseln zu: Navigation, Suche
Zeile 72: Zeile 72:
 
//Attribute
 
//Attribute
 
private String name;
 
private String name;
private String geburtsdatum
+
private String geburtsdatum;
  
 
//Konstruktor
 
//Konstruktor

Version vom 4. Juli 2016, 08:06 Uhr

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.
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:

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.

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).

Vererbung3.JPG

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.

Beispiel:

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.

Vererbung4.JPG


Aufgabe 1

Folgende Begriffe sollen in Form eines Klassendiagramms in eine Klassenhierarchie umgesetzt werden: Rechteck - Kreis - Polygon - Figur - Viereck - Raute - Parallelogramm - Ellipse - Quadrat - Dreieck .
Wähle zu diesem Zweck geeignete Attribute für die einzelnen Klassen. Beachte dabei, welche Attribute von der bzw. den Oberklasse(n) geerbt werden.


Aufgabe 2

Das Generalisierungsbeispiel (Kraftfahrzeuge) soll erweitert werden, so dass möglichst viele Fortbewegungsmittel in der Klassenhierarchie erfasst werden. Ergänze die Klassendiagramme durch geeignete Attribute und berücksichtige dabei die Vererbungshierarchie.

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:

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

Hinweise:

  • 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 definiert 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:


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;
}
}


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;
}
}


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) { ... }
 
...
}


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(){ ... }
 
}


Zur Vertiefung:


Aufgabe 3

Für eine Mitarbeiterverwaltung soll eine Klasse Mitarbeiter mit den Attributen Name, Vorname und Gehalt und entsprechenden Getter-Methoden und eine Setter-Methode für das Gehalt erstellt werden. Zusätzlich werden zwei Unterklassen Filialleiter und Auszubildender angelegt. Der Filialleiter hat als zusätzliches Attribut die bueronummer und die Auszubildenden ausbildungsrichtung und ausbildungsbeginn. Auch hier sind wieder geeignete Getter-Methoden bereitzustellen. Die Klasse Filialleiter erhält nun zwei zusätzliche Methoden: Die Methode gehaltAendern(int gehaltNeu) ändert das Gehalt eines Mitarbeiters und gibt anschließend folgenden (Beispiel-)Text auf der Konsole aus:

Das Gehalt von Max Mustermann beträgt nun 3100 Euro.

Die zweite Methode azubiInfo(Auszubildender a) soll folgenden Text auf der Konsole ausgeben:

Der/Die Auszubildende Erna Musterfrau ist seit 01.04.2014 in der Ausbildungsrichtung Raketenpflege in unserem Betrieb beschäftigt.

Erzeuge nun jeweils eine Instanz von Mitarbeiter, Filialleiter und Auszubildender und teste die beiden obigen Methoden in der Klasse Filialleiter. Verändere dabei zuerst das Gehalt des Mitarbeiters und dann das des Auszubildenden. Was fällt auf? Achte auch darauf, wo beim Auszubildenden die jeweils genutzten Getter-Methoden implementiert sind.


Polymorphie

In der Lösung von Aufgabe 3 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.


public class Kfz {
 
public KfZ() { ... }
 
public void info(){
System.out.println("Ich bin ein Kraftfahrzeug.");
}
}


public class Lkw extends Kfz {
 
public Lkw() { ... }
 
public void info(){
System.out.println("Ich bin ein Lastkraftwagen.");
}
}


public class Pkw extends Kfz {
 
public Pkw() { ... }
 
public void info(){
System.out.println("Ich bin ein Personenkraftwagen.");
}
}


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()
 }
}


Die Ausgabe sieht nun folgendermaßen aus:

Ich bin ein Kraftfahrzeug.
Ich bin ein Lastkraftwagen.
Ich bin ein Personenkraftwagen.
Ich bin ein Lastkraftwagen.
Ich bin ein Personenkraftwagen.

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.


Zur Vertiefung:


Ü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.


Zur Vertiefung:


Aufgabe 4

Es sollen drei Klassen erstellt werden: Viereck, Rechteck als Unterklasse von Viereck und Quadrat als Unterklasse von Rechteck. Jede der Klassen erhält eine Methode umfang(), die die effizienteste Methode der Berechnung des Umfangs für die einzelne Figur nutzt. Achte insbesondere darauf, welche Konstruktoren in der jeweiligen Oberklasse implementiert werden müssen (Die Fehlermeldung in BlueJ ist dabei hilfreich). Teste in einer vierten Klasse die Umsetzung mit folgendem Code (Ausgabe in der Form "Ich bin ein Rechteck. Umfang: 45"):

 public class Test{
 
    public Test(){
        Viereck v = new Viereck(2,3,4,5);
        Viereck r = new Rechteck(2,3);
        Viereck q = new Quadrat (3);
 
        Rechteck r2 = new Rechteck(2,3);
        Quadrat q2 = new Quadrat(3);
 
        v.umfang();
        r.umfang();
        q.umfang();
        q.flaeche();
        r2.umfang();
        q2.umfang();
        q2.flaeche();
 
    }
}

Warum führt der Aufruf q.flaeche() zu einer Fehlermeldung?


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. Klassen, die solche abstrakten Methoden enthalten, sind selbst abstrakt. Im Gegensatz zu konkreten Methoden enthalten abstrakte Methoden 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.

Auch wenn von einer abstrakten Klasse keine Instanzen gebildet werden, kann sie dennoch Konstruktoren enthalten, auf die Unterklassen mittels des Schlüsselworts super zurückgreifen können.

Beispiel: Wir wollen nun die Aufgabe 9.3.1 durch eine abstrakte Klasse Figur erweitern, die nur eine abstrakte Methode umfang enthält. (Die Probleme, die durch die nicht kompatiblen Konstruktoren entstehen, wollen wir hier vernachlässigen.)

public abstract class Figur{
 
//Attribut
private int linienbreite;
 
//Konstruktor, der nur von den Unterklassen genutzt werden soll
protected Figur(int linienbreite){
this.linienbreite=linienbreite;
}
 
//konkrete Methoden, die an die Unterklassen vererbt werden und nur dort sichtbar sein sollen
protected int getLinienbreite(){
return linienbreite;
}
 
protected void setLinienbreite(int linienbreiteNeu){
linienbreite=linienbreiteNeu;
}
 
//abstrakte Methode, die von allen Unterklassen zu implementieren ist
public abstract void umfang();
}

Die abstrakte Klasse Figur verlangt nun von ihren Unterklassen, eine Methode umfang() zu implementieren. Geschieht dies nicht, erhält man folgende Fehlermeldung:

Viereck is not abstract and does not override method umfang() in Figur

Das bedeutet, dass wir die Klasse Viereck ebenfalls abtract setzen müssen und die Methode dann in deren Unterklassen implementieren (oder auch diese abstract setzen) müssen.


Zur Vertiefung: