Vererbung in Java

Bisher haben wir uns noch nicht mit dem Konzept der Vererbung in Java beschäftigt, dies möchte ich jetzt nachholen. Vererbung bedeutet, dass eine Kindklasse die Attribute und Methoden der Elternklasse erhält. Durch den „Erbvorgang“ stehen die Eltern- und Kindklasse in einer sogenannten ist-ein-Beziehung. Die von der Elternklasse abgeleitete Kindklasse ist der Elternklasse ähnlich. Diese Kindklasse kann sich aber noch weiter spezialisieren indem der Kindklasse noch weitere speziellere Methoden und Attribute als der Elternklasse hinzugefügt werden.

Schlüsselwort extends und super

Das Schlüsselwort zum Ableiten einer Klasse ist extends, was durch Ableiten übersetzt werden kann. Der Konstruktor der Oberklasse muss in der Unterklasse aufgerufen werden, dies geschieht mithilfe des Schlüsselworts super.

class Oberklasse {
    // Attribute und Methoden der Oberklasse
}

class Unterklasse extends Oberklasse {
    // Attribute und Methoden der Oberklasse
    // Attribute und Methoden der Unterklasse
}

Beispiel

Wir befassen uns folgend mit einem praktischen Beispiel, dieses hat keinen Anspruch auf Vollständigkeit. Verkehrsmittel können wie in der folgender Hierarchie gegliedert werden.

Alle gelb dargestellten Klassen sind Klassen für konkret instanziierbare Verkehrsmittel, die rot dargestellten Klassen dienen der Unterscheidung, ob sich das Verkehrsmittel an Land oder im Wasser fortbewegt.

So können wir für jede der drei Ebenen Attribute und Methoden festlegen, welche bereits auf der entsprechenden Ebene sinnvoll implementiert werden können. So besitzt beispielsweise jedes Verkehrmittel folgende Eigenschaften:

• Double: Länge
• Double: Breite
• Double: Gewicht
• Boolean: Motorisiert

Auf der roten Ebene können wir dann beispielsweise für Landfahrzeuge folgende zusätzliche Attribute definieren:

• Integer: Höchstgeschwindigkeit
• Boolean: Straßenzulassung

Wenn wir nun als letztes Beispiel auf der gelben Ebene noch den PKW wählen, können wir noch folgende Attribute ergänzen:

• Integer: Sitzplätze
• Integer: Leistung

Implementierung

Wir werden die Klassen hier zur Demonstration nur mit Attributen und einem Konstruktor ausstatten, natürlich sind auch Methoden möglich. Zur besseren Übersichtlichkeit erstelle ich noch das Paket Verkehrsmittel. Pakete behandeln wir im Rahmen der Sichtbarkeit und sollen uns hier nicht weiter stören.

Zunächst definieren wir uns die Klasse Verkehrsmittel.

package Verkehrsmittel;

public class Verkehrsmittel {

    // Attribute
    double laenge, breite, gewicht;
    boolean motorisiert;

    // Konstruktor
    public Verkehrsmittel(double laenge, double breite, double gewicht, boolean motorisiert) {
        this.laenge = laenge;
        this.breite = breite;
        this.gewicht = gewicht;
        this.motorisiert = motorisiert;
    }
}

Jetz schreiben wir die Klasse Landfahrzeuge, welche von Verkehrmittel erbt.

package Verkehrsmittel;

public class Landfahrzeug extends Verkehrsmittel{

    // Attribute
    int hoechstgeschwindigkeit;
    boolean strassenzulassung;

    // Konstruktor
    public Landfahrzeug(double laenge, double breite, double gewicht, boolean motorisiert, int hoechstgeschwindigkeit, boolean strassenzulassung) {

        // Konstruktor der Oberklasse aufrufen
        super(laenge, breite, gewicht, motorisiert);

        this.hoechstgeschwindigkeit = hoechstgeschwindigkeit;
        this.strassenzulassung = strassenzulassung;
    }
}

Nun fehlt uns noch die Klasse PKW, welche wiederum von der Klasse Landfahrzeuge erbt.

package Verkehrsmittel;

public class PKW extends Landfahrzeug{

    // Attribute
    int sitzplaetze, leistung;

    public PKW(double laenge, double breite, double gewicht, boolean motorisiert, int hoechstgeschwindigkeit, boolean strassenzulassung, int sitzplaetze, int leistung) {

        // Konstruktor der Oberklasse aufrufen
        super(laenge, breite, gewicht, motorisiert, hoechstgeschwindigkeit, strassenzulassung);

        this.sitzplaetze = sitzplaetze;
        this.leistung = leistung;
    }
}

Zum Schluss beschreiben wir noch eine Klasse Autobahn mit einer Main-Methode, in welcher wir nun den PKW1 erzeugen. Nach der Instanziierung des Objekts lassen wir uns aus jeder Hierarchie ein Attribut ausgeben.

Als Letztes prüfen wir noch den Typ von PKW1. Dazu verwenden wir den instanceof Operator, der true zurückgibt, wenn die linke Seite des Ausdrucks eine Instanz des Klassennamens auf der rechten Seite ist.

package Verkehrsmittel;

public class Autobahn {

    public static void main(String[] args) {

        PKW PKW1 = new PKW(3.0, 2.15, 3.5, true, 240, true, 5, 180);

        // instanceof prüfen
        System.out.println(PKW1 instanceof PKW);
        System.out.println(PKW1 instanceof Landfahrzeug);
        System.out.println(PKW1 instanceof Verkehrsmittel);

        // Testausgaben aus Attributen verschiedener Klassen
        System.out.println(PKW1.laenge);
        System.out.println(PKW1.strassenzulassung);
        System.out.println(PKW1.leistung);

    }

}

true
true
true
3.0
true
180

Nun haben wir also ein Objekt PKW1 erfolgreich instanziert und können unser Klassengerüst theoretisch noch viel weiter ausbauen und verfeinern.