• Basisklasse und Erweiterung
• Zuweisungskompatibilität
• Überschreiben von Methoden
• Erweiterung und Konstruktoren
• Video

• Abstrakte Klassen
• Interface
  • Gegen das Interface programmieren
  • Mehrfachvererbung per Interface
  • Interfaces werden implementiert

Die Vererbung oder Ableitung bedeutet, dass alle Attribute und Methoden einer Basisklasse von einer anderen Klasse verwendet werden, ohne sie neu zu deklarieren und diese um andere Attribute oder Methoden erweitert.

Die Vererbung wird in Java über das Schlüsselwort extends deklariert und sagt damit aus, was Vererbung in der objektorientierten Programmierung eigentlich ist: Die Erweiterung einer Basisklasse.

Typische Anwendungen sind die Verwaltung von Kunden, Personal und Lieferanten. Alle sind Personen und haben eine Adresse und eine Telefonnummer. Damit bietet sich eine Klasse Person an, die sich um diese Eigenschaften kümmert. Ein Kunde erweitert eine Person um die Eigenschaft, dass er kauft. Ein Lieferant ist eine Person, die Rechnungen stellt und der Mitarbeiter ist eine Person, die in einer Abteilung arbeitet und dafür das Anrecht auf Bezahlung und Urlaub erwirbt.

Gibt es in einem Software-Projekt verschiedene Klassen, die gewisse Gemeinsamkeiten haben, so ist es sinnvoll, nach einer Basisklasse zu suchen, die die gemeinsamen Eigenschaften darstellt.

Beispiel Hausbau

Das Haus steht. Die Maurer sind fertig. Nun soll die Sanitäreinrichtung gebaut werden. Die Sanitärfirma interessiert sich aber nicht für den Bauplan der Maurer. Sie will nur wissen, wie das bestehende Haus um die Rohre und Wasserhähne zu erweitern ist.

Basisklasse und Erweiterung

public class Fahrzeug {
    private int plaetze;
    public int getPlaetze() {
        return plaetze;
    }
    public void setPlaetze(int paraPlaetze) {
        plaetze = paraPlaetze;
    }
}

public class Kraftfahrzeug extends Fahrzeug {
    private int kW;
    public int getKw() {
        return kW;
    }
    public void setKw(int kW) {
        this.kW = kW;
    }

}

class TestFahrzeug {
    static public void main(String[] args) {
        Fahrzeug fahrrad = new Fahrzeug();
        Kraftfahrzeug motorrad = new Kraftfahrzeug();
        Fahrzeug fahrzeug;
        fahrzeug = fahrrad;
        fahrzeug = motorrad;
        ...
        motorrad = (Kraftfahrzeug) fahrzeug;
    }
}

Zuweisungskompatibilität

Fahrzeug fahrrad = new Fahrzeug();
Kraftfahrzeug motorrad = new Kraftfahrzeug();
fahrzeug = motorrad;

Man kann auch sagen, dass ein Motorrad ein Fahrzeug IST und darum alle Bedingungen eines Fahrzeugs erfüllt. Verwendet man also eine (Referenz-)Variable vom Typ Fahrzeug, können alle Eigenschaften von Fahrzeug von einem Motorrad erfüllt werden.

In umgekehrter Richtung gilt das nicht unbedingt, denn nicht jedes Fahrzeug ist auch ein Kraftfahrzeug. So hat ein Segelboot keinen Motor. Würde man auf ein Segelboot also über eine Referenz vom Typ Kraftfahrzeug zugreifen, würden die Zugriffe, die den Motor betreffen, wie etwa die Zugriffe auf die Leistung (kW) ins Leere weisen, weil ein Motor nicht vorhanden ist.

Weiß der Programmierer allerdings, dass das Objekt, das auf das fahrzeug verweist, ursprünglich als Kraftfahrzeug erzeugt worden ist, kann auch eine Rückzuweisung erfolgen. Allerdings muss man den Compiler dazu mit Gewalt überzeugen. Es muss ein Casting stattfinden. Und wie überall in der Welt ist ein Casting immer grausam und sollte vermieden werden.

Fahrzeug fahrrad = new Fahrzeug();
Kraftfahrzeug motorrad = new Kraftfahrzeug();
fahrzeug = motorrad;
Kraffahrzeug kfz = (Kraftfahrzeug)fahrzeug; // Der Programmierer übernimmt die Verantwortung

Object

Überschreiben von Methoden

public class Basis {

    private int zahl = 0;
    
    void setZahl(int neu) {
        zahl = neu;
    }
}

public class Erweiterung extends Basis {
    @Override
    void setZahl(int wert) {
        if  (wert < 0) {
            wert = 0;
        }
        super.setZahl(wert);
    }
}

Erweiterung und Konstruktoren

public class Basis {
    public Basis() {
        System.out.println("Hallo");
    }
}

public class Erweitert extends Basis {
}

public class Test {
    public static void main(String[] args) {
        new Erweitert();
    }
}

Das geschieht auch, wenn die Klasse Erweitert einen expliziten Konstruktor erhält. Um diesen Vorgang deutlicher zu machen, kann der Konstruktor der Basisklasse explizit über den Aufruf von super erfolgen.

public class Erweitert extends Basis {
    public Erweitert() {
        super();
    }
}

Konstruktoren mit Parametern

public class Basis {
    public Basis(int zahl) {
        System.out.println("Hallo "+zahl);
    }
}

public class Erweitert extends Basis {
    public Erweitert() {
        super(12);
    }
}

public class Erweitert extends Basis {
    public Erweitert() {
        // Das lässt der Compiler nicht zu, weil diese Anweisung ...
        java.util.Random zufall = new java.util.Random();
        // ... vor dem super erfolgt.
        super(zufall.nextInt(12));
    }
}

public class Erweitert extends Basis {
    java.util.Random zufall = new java.util.Random();
    public Erweitert() {
        super(zufall.nextInt(12)); // Compiler meckert
    }
}

public class Erweitert extends Basis {
    static java.util.Random zufall = new java.util.Random();
    public Erweitert() {
        super(zufall.nextInt(12));
    }
}

public class Erweitert extends Basis {
    public Erweitert() {
        super(new java.util.Random().nextInt(12));
    }
}

Video