</>wiki.wendler.io

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
# Vererbung

## Superklasse und Subklasse

Vererbung ist ein grundlegendes Konzept in der objektorientierten
Programmierung (OOP), das es ermöglicht, eine neue Klasse auf Basis
einer bestehenden Klasse zu erstellen. Die neue Klasse, die als
**Subklasse** oder Kindklasse bezeichnet wird, erbt die Eigenschaften
und Methoden der bestehenden Klasse, die als **Superklasse** oder
Elternklasse bezeichnet wird. Dies fördert die Wiederverwendbarkeit von
Code und die Hierarchisierung von Klassen.

### Superklasse

Stellen wir uns vor, wir entwickeln eine Anwendung für ein Tierheim. Wir
beginnen mit einer allgemeinen Klasse `Tier`, die grundlegende
Eigenschaften und Methoden für alle Tiere definiert.

``` java
// Superklasse
public class Tier {
    private String name;
    private int alter;

    public Tier(String name, int alter) {
        this.name = name;
        this.alter = alter;
    }

    public void makeSound() {
        System.out.println("Das Tier macht ein Geräusch");
    }

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

    public void setName(String name) {
        this.name = name;
    }

    public int getAlter() {
        return alter;
    }

    public void setAlter(int alter) {
        this.alter = alter;
    }
}

```

### Subklasse

Nun erstellen wir eine Subklasse `Hund`, die von der Klasse `Tier` erbt.
Die Klasse `Hund` wird die Eigenschaften und Methoden der Klasse Tier
übernehmen und kann zusätzliche Eigenschaften und Methoden hinzufügen
oder bestehende Methoden überschreiben.

In diesem Beispiel erbt die Klasse `Hund` die Eigenschaften `name` und
`alter` sowie die Methode `makeSound` von der Klasse `Tier`.

``` java
// Subklasse
public class Hund extends Tier {
    private String rasse;

    public Hund(String name, int alter, String rasse) {
        super(name, alter); // Aufruf des Konstruktors der Superklasse
        this.rasse = rasse;
    }

    @Override
    public void makeSound() {
        System.out.println("Der Hund bellt");
    }

    // Getter und Setter
    public String getRasse() {
        return rasse;
    }

    public void setRasse(String rasse) {
        this.rasse = rasse;
    }
}

```

#### Aufruf des Konstruktors der Superklasse: super()

Beachte Zeile 6: Hier wird durch `super(name, alter)` der Konstruktor
der Superklasse `Tier` aufgerufen und die dort geforderten Parameter
`name` und `alter` übergeben.

Eigenschaften werden immer im Konstruktor der Klasse übergeben, die die
Eigenschaften definiert.

So können auf dem Weg von einer Superklasse zur nächsten Subklasse und
vielleicht sogar noch einer und noch einer Subklasse einige
Eigenschaften und Parameter zusammenkommen.

Immer wenn eine Superklasse Parameter übergeben bekommt, muss in der
Subklasse der **Konstruktor der Superklasse** mit eben diesen Parametern
aufgerufen werden.

Dieser Aufruf findet im Konstruktor statt.

Der Aufruf `super(variable_x, variable_y)` ist **immer der erste Aufruf
im Konstruktor**.

``` java
...
    public Hund(String name, int alter, String rasse) {
        super(name, alter); // Aufruf des Konstruktors der Superklasse
        this.rasse = rasse;
    }
...
```

#### Überschreiben von Methoden der Superklass: \@override

Die Methode `makeSound` wird in der Klasse `Hund` überschrieben, um ein
spezifisches Verhalten für Hunde zu definieren.

``` java
    ...
    @Override
    public void makeSound() {
        System.out.println("Der Hund bellt");
    }
    ...
```

### Zusammenspiel/ Verwendung der Klassen

``` java
public class Main {
    public static void main(String[] args) {
        Tier allgemeinesTier = new Tier("Allgemeines Tier", 5);
        allgemeinesTier.makeSound(); // Ausgabe: Das Tier macht ein Geräusch

        Hund meinHund = new Hund("Bello", 3, "Labrador");
        meinHund.makeSound(); // Ausgabe: Der Hund bellt

        System.out.println("Name: " + meinHund.getName()); // Ausgabe: Name: Bello
        System.out.println("Alter: " + meinHund.getAlter()); // Ausgabe: Alter: 3
        System.out.println("Rasse: " + meinHund.getRasse()); // Ausgabe: Rasse: Labrador
    }
}

```