Die Vererbung ist ein grundlegendes Konzept der objektorientierten Programmierung, bei dem eine Klasse (die Unterklasse) Eigenschaften und Methoden von einer anderen Klasse (der Basisklasse oder Superklasse) erbt.
class Fahrzeug:
def __init__(self, marke, modell):
self.marke = marke
self.modell = modell
class Auto(Fahrzeug):
pass
mein_auto = Auto("Tesla", "Model S")
print(mein_auto.marke) # Ausgabe: "Tesla"Überschreiben von Methoden
Manchmal möchten wir das Verhalten einer geerbten Methode in der Unterklasse ändern. Dafür können wir die Methode in der Unterklasse überschreiben.
class Fahrzeug:
def beschleunigen(self):
return "Das Fahrzeug beschleunigt."
class Auto(Fahrzeug):
def beschleunigen(self):
return "Das Auto beschleunigt schnell."
mein_auto = Auto()
print(mein_auto.beschleunigen()) # Ausgabe: "Das Auto beschleunigt schnell."Verwenden von `super()`
Um auf die Methoden der Basisklasse zuzugreifen, können wir die Funktion `super()` verwenden. Dies ist besonders nützlich, wenn wir den `__init__`-Konstruktor der Basisklasse aufrufen möchten.
class Fahrzeug:
def __init__(self, marke, modell):
self.marke = marke
self.modell = modell
class Auto(Fahrzeug):
def __init__(self, marke, modell, sitze):
super().__init__(marke, modell)
self.sitze = sitze
mein_auto = Auto("Tesla", "Model S", 5)
print(mein_auto.sitze) # Ausgabe: 5Abstrakte Klassen und abstrakte Methoden
Abstrakte Klassen sind Klassen, die nicht instanziiert werden können. Sie dienen als Basis für andere Klassen und enthalten abstrakte Methoden, die in abgeleiteten Klassen implementiert werden müssen. In Python verwenden wir das Modul `abc` (Abstract Base Classes), um abstrakte Klassen und Methoden zu definieren.
from abc import ABC, abstractmethod
class Tier(ABC):
@abstractmethod
def spricht(self):
pass
class Hund(Tier):
def spricht(self):
return "Wuff!"Polymorphie und Interfaces
Polymorphie ermöglicht es, dass verschiedene Klassen dieselbe Schnittstelle implementieren und somit austauschbar verwendet werden können. In Python gibt es keine expliziten Interfaces wie in Java, aber abstrakte Klassen können als Interfaces verwendet werden.
from abc import ABC, abstractmethod
class SprechendesTier(ABC):
@abstractmethod
def spricht(self):
pass
class Hund(SprechendesTier):
def spricht(self):
return "Wuff!"
class Katze(SprechendesTier):
def spricht(self):
return "Miau!"
def tier_sprache(tier):
print(tier.spricht())
mein_hund = Hund()
meine_katze = Katze()
tier_sprache(meine_katze) # Ausgabe: "Miau!"Mehrfachvererbung
In Python ist es möglich, mehrere Basisklassen für eine Klasse zu haben. Dies wird als Mehrfachvererbung bezeichnet. Die Methodenauflösungsreihenfolge (MRO) bestimmt, welche Methode aufgerufen wird, wenn mehrere Basisklassen dieselbe Methode haben.
class A:
def methode(self):
return "Klasse A"
class B:
def methode(self):
return "Klasse B"
class C(A, B):
pass
c = C()
print(c.methode()) # Ausgabe: "Klasse A"Mixins
Mixins sind kleine Klassen, die spezifische Funktionalitäten anbieten und in größere Klassen einfließen können. Sie sind ein weiteres Beispiel für Mehrfachvererbung.
class SprecherMixin:
def spricht(self):
return "Das Objekt spricht."
class Hund(SprecherMixin):
pass
class Katze(SprecherMixin):
pass
mein_hund = Hund()
meine_katze = Katze()
print(mein_hund.spricht()) # Ausgabe: "Das Objekt spricht."
print(meine_katze.spricht()) # Ausgabe: "Das Objekt spricht."Durch das Verständnis von Vererbung, Polymorphie, abstrakten Klassen und Mehrfachvererbung kannst Du Deine Python-Programme modularer und wiederverwendbar gestalten. Du hast jetzt ein solides Verständnis der objektorientierten Programmierung in Python und kannst diese Konzepte in Deinen eigenen Projekten anwenden.