Einführung in Kapselung und Abstraktion

Kapselung und Abstraktion sind grundlegende Prinzipien der objektorientierten Programmierung (OOP). Sie helfen dabei, Komplexität zu bewältigen und Code übersichtlich zu strukturieren.

Die Kapselung schränkt den direkten Zugriff auf die Daten eines Objekts ein, während die Abstraktion Implementierungsdetails verbirgt und nur die wesentlichen Funktionen offenlegt.

Was ist Kapselung?

Kapselung bedeutet, Daten (Attribute) und Methoden innerhalb einer Klasse zu bündeln und den direkten Zugriff darauf einzuschränken.

# Example of encapsulation
class Person:
    # Private attribute (indicated by double underscores)
    def __init__(self, name):
        self.__name = name

    # Public method to access the private attribute
    def get_name(self):
        return self.__name

person = Person("Alice")
# Accessing private data via a public method
print(person.get_name())

Private Attribute

In Python werden private Attribute durch zwei Unterstriche __ gekennzeichnet. Außerhalb der Klasse kann nicht direkt auf sie zugegriffen werden.

# Private attributes
class Car:
    def __init__(self, brand):
        self.__brand = brand  # Private attribute

    def get_brand(self):
        # Public method to access the private attribute
        return self.__brand

car = Car("Toyota")
print(car.get_brand())  # Outputs: Toyota

Was ist Abstraktion?

Die Abstraktion verbirgt die internen Implementierungsdetails einer Klasse und legt für den Benutzer nur die erforderlichen Funktionen offen.

# Example of abstraction
from abc import ABC, abstractmethod

# Abstract Base Class
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# Subclass implementing the abstract method
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

circle = Circle(5)
print(circle.area())  # Outputs: 78.5

Abstrakte Klassen

Abstrakte Klassen sind Klassen, von denen nicht direkt eine Instanz erstellt werden kann. Sie dienen dazu, eine gemeinsame Schnittstelle für ihre Unterklassen zu definieren.

# Abstract Base Class with multiple subclasses
from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

dog = Dog()
cat = Cat()
dog.speak()  # Outputs: Dog barks
cat.speak()  # Outputs: Cat meows

Kapselung vs. Abstraktion

Kapselung und Abstraktion sind eng miteinander verwandte, aber dennoch unterschiedliche Konzepte:

• Kapselung: Beschränkt den Zugriff auf Daten innerhalb einer Klasse.
• Abstraktion: Verbirgt Implementierungsdetails und stellt eine klare Schnittstelle bereit.

Vorteile von Kapselung und Abstraktion

Hier sind einige wichtige Vorteile:

• Die Sicherheit und Wartbarkeit des Codes werden verbessert.
• Modularer und wiederverwendbarer Code wird gefördert.
• Der Code wird leichter lesbar und verständlich.

Häufige Fehler bei Kapselung und Abstraktion

Diese Fehler sollten Sie vermeiden:

• Direkter Zugriff auf private Attribute, anstatt Getter- und Setter-Methoden zu verwenden.
• Abstrakte Klassen direkt instanziieren.
• Nicht alle abstrakten Methoden in Unterklassen implementieren.

Was haben Sie gelernt?

In dieser Lektion haben Sie Folgendes gelernt:

• Was Kapselung ist und wie Sie mithilfe privater Attribute den Zugriff auf Daten einschränken.
• Was Abstraktion ist und wie Sie abstrakte Klassen zum Definieren gemeinsamer Schnittstellen verwenden.
• Welche Unterschiede und Vorteile Kapselung und Abstraktion bieten.

Sehr gut! Fahren wir mit dem nächsten Thema fort.