Vererbung: Unterschied zwischen den Versionen

Aktuelle Version vom 13. Juli 2016, 07:45 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:

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.

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

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.

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:

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

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

public class Mitarbeiter{
    //Attribute
    private String name;
    private String vorname;
    private int gehalt;
 
    //Konstruktoren
    public Mitarbeiter(String name, String vorname, int gehalt){
        this.name=name;
        this.vorname=vorname;
        this.gehalt=gehalt;
    }
 
    public Mitarbeiter(String name, String vorname){
      this.name=name;
      this.vorname=vorname; 
    }
 
    //Getter- und Setter-Methoden
    public String getName(){
        return name;
    }
 
    public String getVorname(){
        return vorname;
    }
 
    public int getGehalt(){
        return gehalt;
    }
 
    public void setGehalt(int gehaltNeu){
        gehalt=gehaltNeu;
    }   
}

public class Auszubildender extends Mitarbeiter{
    //weitere Attribute
    private String ausbildungsrichtung;
    private String ausbildungsbeginn;
 
    //Konstruktor
    public Auszubildender(String name, String vorname, int gehalt, String ausbildungsrichtung, String ausbildungsbeginn){
        super(name, vorname, gehalt);
        this.ausbildungsrichtung=ausbildungsrichtung;
        this.ausbildungsbeginn=ausbildungsbeginn;
    }
 
    //Getter-Methoden
    public String getAusbildungsrichtung(){
        return ausbildungsrichtung;
    }
 
    public String getAusbildungsbeginn(){
        return ausbildungsbeginn;
    }
}

public class Filialleiter extends Mitarbeiter{
    //zusätzliche Attribute
    private String bueronr;
 
    //Konstruktor
    public Filialleiter(String name, String vorname, int gehalt, String bueronr){
     super(name, vorname, gehalt);
     this.bueronr=bueronr;
    }
 
    //Getter- und Setter-Methoden
    public String getBueronr(){
        return bueronr;}
 
    public void setBueronr(String bueronrNeu){
        bueronr=bueronrNeu;
    }
 
    //weitere Methoden
    public void gehaltAendern(Mitarbeiter m, int gehaltNeu){
        m.setGehalt(gehaltNeu);
        System.out.println("Das Gehalt von "+m.getVorname()+" "+m.getName()+" beträgt nun "+m.getGehalt()+" Euro.");
    }
 
     public void azubiInfo(Auszubildender a){
       System.out.println("Der/Die Auszubildende "+a.getVorname()+" "+a.getName()+" arbeitet seit "+a.getAusbildungsbeginn()+" in der Ausbildungsrichtung "+a.getAusbildungsrichtung()+" im Betrieb.");
}
}

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:

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

public class Viereck {
    //Attribute - public um direkten Zugriff durch die Unterklasse zu ermöglichen
    public int a;
    public int b;
    public int c;
    public int d;
 
    public Viereck(int a, int b, int c, int d){
        this.a=a;
        this.b=b;
        this.c=c;
        this.d=d;
    }
 
    public Viereck(int a, int b){
        this.a=a;
        this.b=b;
        c=a;
        d=b;
    }
 
    public Viereck(int a){
        this.a=a;
        b=a;
        c=a;
        d=a;
    }
 
 
 
    public void umfang(){
        int u=a+b+c+d;
        System.out.println("Ich bin ein Viereck. Umfang = "+u);
    }
 
}

public class Rechteck extends Viereck {
 
    public Rechteck(int a, int b){
        super(a,b);
    }
 
     public Rechteck(int a){
        super(a);
    }
 
 
    public void umfang(){
        int u=2*a + 2*b;
        System.out.println("Ich bin ein Rechteck. Umfang = "+u);
    }
 
}

public class Quadrat extends Rechteck {
 
    public Quadrat(int a){
        super(a);
    }
 
 
    public void umfang(){
        int u=4*a;
        System.out.println("Ich bin ein Quadrat. Umfang = "+u);
    }
 
    public void flaeche (){
        int f=a*a;
        System.out.println("Ich bin ein Quadrat. Flaeche = "+f);
}
}

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: