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.
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.
// 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;
}
}
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.
// 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;
}
}
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.
...
public Hund(String name, int alter, String rasse) {
super(name, alter); // Aufruf des Konstruktors der Superklasse
this.rasse = rasse;
}
...
Die Methode makeSound wird in der Klasse Hund überschrieben, um ein
spezifisches Verhalten für Hunde zu definieren.
...
@Override
public void makeSound() {
System.out.println("Der Hund bellt");
}
...
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
}
}