Abstrakte Klassen und Methoden

Abstrakte Klassen sind Klassen, von denen keine Instanzen direkt erstellt werden können und die abstrakte Methoden enthalten, die von Unterklassen implementiert werden müssen.

Stell es dir wie ein Formular vor: Eine abstrakte Klasse ist wie ein obligatorisches Formular, bei dem einige Felder Pflichtfelder (abstrakte Methoden) und andere optional sind (konkrete Methoden). Du kannst das Formular selbst nicht einreichen – du musst zuerst alle Pflichtfelder ausfüllen. Ebenso kannst du keine Instanzen einer abstrakten Klasse erstellen, solange nicht alle abstrakten Methoden in einer Unterklasse implementiert sind.

Importiere das abc-Modul, um abstrakte Klassen zu erstellen:

from abc import ABC, abstractmethod

Erstelle eine abstrakte Klasse mit abstrakten Methoden:

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    
    @abstractmethod
    def perimeter(self):
        pass
    
    def describe(self):
        return "This is a shape"  # Konkrete Methode (hat eine Implementierung)

Der @abstractmethod-Decorator kennzeichnet Methoden, die von Unterklassen implementiert werden müssen – das sind die „Pflichtfelder“ in deinem Formular. Reguläre Methoden wie describe() können Implementierungen haben und werden unverändert vererbt – das sind die „vorausgefüllten Felder“.

Warum abstrakte Klassen verwenden? Sie erzwingen einen Vertrag. Wenn du eine Klasse Shape erstellst, sagst du damit: „Jede Form MUSS ihre Fläche und ihren Umfang berechnen können.“ Das verhindert Fehler, bei denen du vergessen könntest, wichtige Methoden zu implementieren.

Versuche, eine Instanz der abstrakten Klasse zu erstellen:

# Dies führt zu einem Fehler:
# shape = Shape()  # TypeError: Can't instantiate abstract class

Dieser Fehler ist beabsichtigt – es ist, als würdest du versuchen, ein leeres Formular abzuschicken. Python sagt: „Du hast die erforderlichen Felder (Flächeninhalt und Umfangsmethoden) noch nicht ausgefüllt!“

Erstelle eine konkrete Unterklasse, die alle abstrakten Methoden implementiert:

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2
    
    def perimeter(self):
        return 2 * 3.14 * self.radius

Jetzt haben wir „alle erforderlichen Felder ausgefüllt“ – wir haben sowohl area() als auch perimeter() implementiert. Die Klasse Circle ist nun eine vollständige, konkrete Klasse, von der Instanzen erstellt werden können.

Jetzt kannst du Instanzen der konkreten Klasse erstellen:

circle = Circle(5)
print(circle.area())
print(circle.perimeter())
print(circle.describe())  # Geerbte konkrete Methode

Erstelle eine weitere konkrete Unterklasse:

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width  self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)

rectangle = Rectangle(4, 6)
print(rectangle.area())
print(rectangle.perimeter())

Ausgabe:

78.5
31.400000000000002
This is a shape
24
20

Abstrakte Klassen definieren einen Vertrag, an den sich Unterklassen halten müssen. Verwende ABC und @abstractmethod, um abstrakte Klassen zu erstellen. Unterklassen müssen alle abstrakten Methoden implementieren, andernfalls sind auch sie abstrakt. Das gewährleistet Konsistenz und verhindert unvollständige Implementierungen.