≪ View Page

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Next revision		Previous revision
programmierung:klassen:vererbung [2024/08/25 16:13] – created sweprogrammierung:klassen:vererbung [2025/12/20 14:53] (current) – external edit 127.0.0.1
Line 1: Line 1:
-====== Vererbung ======+# Vererbung
  
-===== Superklasse und Subklasse =====+## 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.+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.
  
-**Beispiel: Vererbung in Java** +### 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.+
  
-<code java  | Tier.java>+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 // Superklasse
 public class Tier { public class Tier {
Line 41: Line 50:
 } }
  
-</code>+``` 
 + 
 +### 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 
 +    } 
 +} 
 + 
 +```