class Papagei:
    pass

Hier ist Papagei eine leere Klasse. Instanzen dieser Klasse werden später erstellt.

Objekt

Ein Objekt (oder Instanz) ist eine konkrete Realisierung einer Klasse. Wenn eine Klasse definiert wird, wird kein Speicher allokiert; nur die Vorlage existiert. Das Instanziieren der Klasse erstellt das Objekt.

obj = Papagei()

Im folgenden Beispiel bauen wir eine funktionale Papagei-Klasse und erstellen zwei Instanzen, blu und woo:

class Papagei:
    # Klassenattribut
    art = "Vogel"
    # Instanzattribute
    def __init__(self, name, alter):
        self.name = name
        self.alter = alter
# Klasse instanziieren
blu = Papagei("Blu", 10)
woo = Papagei("Woo", 15)
# Klassenattribute zugreifen
print("Blu ist ein {}".format(blu.__class__.art))
print("Woo ist auch ein {}".format(woo.__class__.art))
# Instanzattribute zugreifen
print("{} ist {} Jahre alt".format(blu.name, blu.alter))
print("{} ist {} Jahre alt".format(woo.name, woo.alter))

Ausgabe

Blu ist ein Vogel Woo ist auch ein Vogel Blu ist 10 Jahre alt Woo ist 15 Jahre alt

In diesem Snippet ist art ein Klassenattribut, das von allen Papageien geteilt wird, während name und alter Instanzattribute sind, die für jedes Objekt einzigartig sind.

Methoden

Methoden sind Funktionen, die innerhalb einer Klasse definiert sind und das Objektverhalten beschreiben. Sie werden auf Instanzen der Klasse aufgerufen.

class Papagei:
    def __init__(self, name, alter):
        self.name = name
        self.alter = alter
    def sing(self, lied):
        return f"{self.name} singt {lied}"
    def tanzen(self):
        return f"{self.name} tanzt jetzt"
# Instanziieren und Methoden verwenden
blu = Papagei("Blu", 10)
print(blu.sing("'Happy'"))
print(blu.tanzen())

Ausgabe

Blu singt 'Happy' Blu tanzt jetzt

Vererbung

Vererbung ermöglicht es einer neuen Klasse, Attribute und Methoden von einer bestehenden Klasse zu erben, was Code-Wiederverwendung und logische Hierarchie fördert.

# Basisklasse
class Vogel:
    def __init__(self):
        print("Vogel ist bereit")
    def werIstDas(self):
        print("Vogel")
    def schwimmen(self):
        print("Schneller schwimmen")
# Abgeleitete Klasse
class Pinguin(Vogel):
    def __init__(self):
        super().__init__()
        print("Pinguin ist bereit")
    def werIstDas(self):
        print("Pinguin")
    def laufen(self):
        print("Schneller laufen")
peggy = Pinguin()
peggy.werIstDas()
peggy.schwimmen()
peggy.laufen()

Ausgabe

Vogel ist bereit Pinguin ist bereit Pinguin Schneller schwimmen Schneller laufen

Kapselung

Kapselung beschränkt den direkten Zugriff auf den internen Zustand eines Objekts und schützt die Datenintegrität. In Python werden private Attribute durch einen führenden Unterstrich (einfach oder doppelt) gekennzeichnet.

class Computer:
    def __init__(self):
        self.__maxpreis = 900
    def verkaufen(self):
        print(f"Verkaufspreis: {self.__maxpreis}")
    def setMaxPreis(self, preis):
        self.__maxpreis = preis
c = Computer()
c.verkaufen()
# Direkter Modifikationsversuch
c.__maxpreis = 1000
c.verkaufen()
# Setter-Methode verwenden
c.setMaxPreis(1000)
c.verkaufen()

Ausgabe

Verkaufspreis: 900 Verkaufspreis: 900 Verkaufspreis: 1000

Polymorphie

Polymorphie erlaubt es, Objekte verschiedener Klassen über eine gemeinsame Schnittstelle zu behandeln, was flexiblen Code ermöglicht, der auf verschiedenen Objekttypen operieren kann.

class Papagei:
    def fliegen(self):
        print("Papagei kann fliegen")
    def schwimmen(self):
        print("Papagei kann nicht schwimmen")
class Pinguin:
    def fliegen(self):
        print("Pinguin kann nicht fliegen")
    def schwimmen(self):
        print("Pinguin kann schwimmen")
# Gemeinsame Schnittstelle
def flug_test(vogel):
    vogel.fliegen()
blu = Papagei()
peggy = Pinguin()
flug_test(blu)
flug_test(peggy)

Ausgabe

Papagei kann fliegen Pinguin kann nicht fliegen

Wichtigste Erkenntnisse

• OOP strukturiert Code für Klarheit und Wartbarkeit.
• Klassen ermöglichen Code-Wiederverwendung durch Vererbung.
• Kapselung schützt interne Daten.
• Polymorphie bietet flexible Schnittstellen über Objekttypen hinweg.