Vererbung ist ein Eckpfeiler der objektorientierten Programmierung (OOP) und ermöglicht die Erstellung neuer Klassen (Kind- oder Unterklassen) auf Basis bereits existierender Klassen (Eltern- oder Superklassen). Dies fördert die Wiederverwendbarkeit von Code, reduziert Redundanz und fördert einen gut strukturierten Codebestand. Dieses Tutorial befasst sich eingehend mit den Vererbungsmechanismen in Python, untersucht verschiedene Arten und demonstriert praktische Anwendungen.
Inhaltsverzeichnis
- Methodenüberschreibung
- Multiple Vererbung
- Mehrstufige Vererbung
- Praktisches Beispiel: Eine Formenhierarchie
Methodenüberschreibung
Methodenüberschreibung erlaubt es einer Unterklasse, eine spezialisierte Implementierung für eine von der Oberklasse geerbte Methode bereitzustellen. Dies passt das geerbte Verhalten an, ohne die Oberklasse zu verändern.
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print("Generelles Tiergeräusch")
class Dog(Animal):
def speak(self):
print("Wau!")
class Cat(Animal):
def speak(self):
print("Miau!")
animal = Animal("Generisches Tier")
animal.speak() # Ausgabe: Generelles Tiergeräusch
dog = Dog("Buddy")
dog.speak() # Ausgabe: Wau!
cat = Cat("Whiskers")
cat.speak() # Ausgabe: Miau!
Die Funktion super()
ermöglicht den Zugriff auf die Methode der Oberklasse und erlaubt die Verwendung sowohl des Oberklassen- als auch des Unterklassenverhaltens.
class Dog(Animal):
def speak(self):
super().speak()
print("Wau! (aus der Dog Klasse)")
Multiple Vererbung
Python unterstützt multiple Vererbung, bei der eine Klasse von mehreren Elternklassen erbt und deren Funktionalitäten kombiniert. Die Behandlung von Namenskonflikten bei Methoden (das „Diamantenproblem“) erfordert jedoch sorgfältige Überlegung. Pythons Method Resolution Order (MRO) mittels C3-Linearisierung sorgt für eine vorhersehbare Konfliktlösung. Man kann den MRO mit ClassName.__mro__
inspizieren.
class Flyer:
def move(self):
print("Fliegt!")
class Swimmer:
def move(self):
print("Schwimmt!")
class FlyingFish(Flyer, Swimmer):
pass
flying_fish = FlyingFish()
print(FlyingFish.__mro__) # MRO überprüfen
flying_fish.move() # Ausgabe: Fliegt! (Flyers move wird zuerst aufgrund des MRO aufgerufen)
Mehrstufige Vererbung
Mehrstufige Vererbung erzeugt eine Hierarchie, in der eine Unterklasse von einer anderen Unterklasse erbt, die selbst von einer Oberklasse erbt. Dies baut auf bestehenden Klassen mit zunehmender Spezialisierung auf.
class Animal:
def __init__(self, name):
self.name = name
class Mammal(Animal):
def __init__(self, name, fur_color):
super().__init__(name)
self.fur_color = fur_color
class Dog(Mammal):
def __init__(self, name, fur_color, breed):
super().__init__(name, fur_color)
self.breed = breed
dog = Dog("Buddy", "Braun", "Golden Retriever")
print(f"{dog.name} ist ein {dog.breed} mit {dog.fur_color} Fell.")
# Ausgabe: Buddy ist ein Golden Retriever mit Braun Fell.
Praktisches Beispiel: Eine Formenhierarchie
Illustrieren wir Vererbung mit einem praktischen Beispiel: einer Hierarchie von Formen. Wir beginnen mit einer Basisklasse Shape
und leiten die Klassen Circle
und Rectangle
davon ab.
import math
class Shape:
def __init__(self, name):
self.name = name
def area(self):
raise NotImplementedError("Area-Methode muss in Unterklassen implementiert werden")
class Circle(Shape):
def __init__(self, name, radius):
super().__init__(name)
self.radius = radius
def area(self):
return math.pi * self.radius**2
class Rectangle(Shape):
def __init__(self, name, width, height):
super().__init__(name)
self.width = width
self.height = height
def area(self):
return self.width * self.height
circle = Circle("Kreis", 5)
rectangle = Rectangle("Rechteck", 4, 6)
print(f"Die Fläche des {circle.name} beträgt: {circle.area()}")
print(f"Die Fläche des {rectangle.name} beträgt: {rectangle.area()}")
Dieses Beispiel zeigt, wie Vererbung die Codeorganisation und Wiederverwendbarkeit erleichtert. Die area
-Methode ist in der Basisklasse definiert und zwingt Unterklassen, ihre spezifischen Flächenberechnungen zu implementieren.
Dieses Tutorial bietet eine umfassende Einführung in die Klassenvererbung in Python. Die weitere Erkundung abstrakter Basisklassen, Interfaces und Designmuster, die Vererbung nutzen, wird Ihre OOP-Kenntnisse deutlich verbessern.