6.1 Vererbung ist einfach
Vererbung ist ein grundlegendes Konzept der objektorientierten Programmierung (OOP), das es einer Klasse (genannt Kindklasse oder Subklasse) erlaubt, Felder und Methoden einer anderen Klasse (genannt Elternklasse oder Superklasse) zu erben.
Diese Vorgehensweise ermöglicht es, allgemeinere Klassen zu erstellen und Code wiederzuverwenden, wodurch die Organisation und Wartbarkeit des Codes verbessert wird.
Warum braucht man Vererbung?
Angenommen, du musst irgendeinen Code schreiben und hast entschieden, dies in Form einer Klasse zu machen. Dann erfährst du, dass in deinem Projekt bereits eine Klasse existiert, die fast alles tut, was du in deiner Klasse brauchst. Du könntest einfach den Code dieser Klasse in deine kopieren und verwenden.
Oder du könntest "quasi kopieren". Du kannst diese Klasse als Elternklasse deiner Klasse deklarieren, und dann fügt Python deiner Klasse das Verhalten der Elternklasse hinzu.
Stell dir vor, du bist die Natur und willst einen Hund erschaffen. Was wäre schneller – einen Hund aus einer Bakterie in einer Milliarde Jahren zu erschaffen oder einen Wolf in 200.000 Jahren zu domestizieren?
Beispiel für grundlegende Vererbung
Angenommen, du hast eine Elternklasse Animal mit einem Feld name:
class Animal:
def __init__(self, name):
self.name = name
Wir möchten zwei abgeleitete Klassen dafür erstellen — Dog und Cat, und beiden die Methode speak hinzufügen:
class Dog(Animal):
def speak(self):
return f"{self.name} says Woof!"
class Cat(Animal):
def speak(self):
return f"{self.name} sagt Miau!"
In dem obigen Beispiel erben die Kindklassen Dog und Cat von Animal und fügen die Methode speak hinzu.
Die Klasse Dog:
- Erbt das Attribut
namevonAnimal. - Fügt die Methode
speakhinzu, die einen für Hunde spezifischen String zurückgibt.
Die Klasse Cat:
- Erbt das Attribut
namevonAnimal. - Fügt die Methode
speakhinzu, die einen für Katzen spezifischen String zurückgibt.
Die finale Version des Codes sieht so aus:
class Animal:
def __init__(self, name):
self.name = name
class Dog(Animal):
def speak(self):
return f"{self.name} says Woof!"
class Cat(Animal):
def speak(self):
return f"{self.name} sagt Miau!"
dog = Dog("Buddy")
cat = Cat("Whiskers")
print(dog.speak()) # Ausgabe: Buddy says Woof!
print(cat.speak()) # Ausgabe: Whiskers sagt Miau!
In diesem Beispiel ist Animal die Elternklasse, und Dog und Cat sind die Kindklassen. Die Kindklassen erben das Attribut name und die Methode __init__ von der Elternklasse Animal, fügen aber die Methoden speak hinzu.
6.2 Unter der Haube der Vererbung
Wenn du deiner Klasse einen Elternteil hinzufügst, ist das sehr ähnlich, als würdest du den Code der Elternklasse in deine Klasse kopieren.
class Animal:
def __init__(self, name):
self.name = name
class Dog(Animal):
def __init__(self, name):
super().__init__(name) # Aufruf des Konstruktors der Elternklasse
def speak(self):
return f"{self.name} says Woof!"
class Cat(Animal):
def __init__(self, name):
super().__init__(name) # Aufruf des Konstruktors der Elternklasse
def speak(self):
return f"{self.name} sagt Miau!"
dog = Dog("Buddy")
cat = Cat("Whiskers")
print(dog.speak()) # Ausgabe: Buddy says Woof!
print(cat.speak()) # Ausgabe: Whiskers sagt Miau!
Das ist keine völlig exakte Beschreibung, aber wenn du noch nie mit dem Konzept der Vererbung zu tun hattest, kannst du vorerst so darüber denken. Später fügen wir dem noch weitere Details hinzu.
6.3 Vererbungshierarchie
Sehr oft, wenn ein komplexes Modell einer großen Gruppe von Klassen entworfen wird, kannst du auf eine ganze Vererbungshierarchie stoßen.
Zum Beispiel hast du die Klasse Animal – das ist die Basisklasse für alle Tiere:
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
raise NotImplementedError("Subclass must implement abstract method")
Wir haben ihr sogar die Methode speak hinzugefügt, aber da ein abstraktes Tier nicht spricht, wirft diese Methode einfach eine Ausnahme NotImplementedError – das ist Standardpraxis.
Dann fügen wir Zwischenklassen hinzu, die den Tierkategorien entsprechen: Mammal für Säugetiere und Bird für Vögel.
class Mammal(Animal):
def __init__(self, name, fur_color):
super().__init__(name) # Aufruf des Konstruktors der Elternklasse
self.fur_color = fur_color
class Bird(Animal):
def __init__(self, name, wing_span):
super().__init__(name) # Aufruf des Konstruktors der Elternklasse
self.wing_span = wing_span
def fly(self):
return f"{self.name} fliegt mit einer Flügelspannweite von {self.wing_span} Metern."
Und schließlich, nur im letzten Schritt tauchen die Klassen für spezifische Tierarten auf:
class Dog(Mammal):
def speak(self):
return f"{self.name} says Woof!"
class Cat(Mammal):
def speak(self):
return f"{self.name} sagt Miau!"
class Parrot(Bird):
def speak(self):
return f"{self.name} says Squawk!"
Mit ihnen arbeitet normalerweise der finale Code:
animals = [Dog("Buddy", "brown"), Cat("Whiskers", "white"), Parrot("Polly", 0.5)]
for animal in animals:
print(animal.speak())
print(f"{dog.name} hat {dog.fur_color} Fell.") # Ausgabe: Buddy hat braunes Fell.
print(f"{cat.name} hat {cat.fur_color} Fell.") # Ausgabe: Whiskers hat weißes Fell.
print(parrot.fly()) # Ausgabe: Polly fliegt mit einer Flügelspannweite von 0.5 Metern.
Obwohl es technisch gesehen keine Verbote für die Erstellung von Hierarchien mit Dutzenden von Vorfahren gibt, ist es wichtig, im Hinterkopf zu behalten, dass man ohne Notwendigkeit besser die Einfachheit bewahren sollte. In der Einfachheit liegt die Stärke.
GO TO FULL VERSION