Python-Kurs (Teil 15): Polymorphie – gleiche Methode, verschiedene Objekte

[computerdirk]

Hallo und willkommen zurück!

Du hast bereits gelernt, wie man Baupläne für Objekte erstellt (Klassen) und wie man diese Baupläne wiederverwendet (Vererbung). Heute geht es um die Polymorphie, was "viele Gestalten" bedeutet.

Was ist Polymorphie?

Polymorphie erlaubt es, dass eine Methode in verschiedenen Klassen dasselbe tut, aber auf ihre eigene, spezifische Art.

Stell dir den Befehl "Sprich!" vor.

• Wenn du ihn einem Menschen gibst, wird er sprechen.
  
• Wenn du ihn einem Hund gibst, wird er bellen.
  
• Wenn du ihn einem Papagei gibst, wird er vielleicht nachplappern.
  

Der Befehl (Sprich!) ist immer derselbe, aber er hat viele verschiedene Gestalten, je nachdem, welchem Objekt du ihn gibst.

Polymorphie in Aktion

Wir nutzen die Klassen Person und Schueler aus der letzten Lektion. Wir fügen eine Methode vorstellen() hinzu, die sich in jeder Klasse anders verhält.

Beispiel:

Code:

class Person:
    def __init__(self, name, alter):
        self.name = name
        self.alter = alter

    def vorstellen(self):
        print(f"Hallo, mein Name ist {self.name} und ich bin {self.alter} Jahre alt.")

class Schueler(Person):
    def __init__(self, name, alter, schulklasse):
        super().__init__(name, alter)
        self.schulklasse = schulklasse

    # Wir überschreiben die Methode vorstellen() der Elternklasse!

    def vorstellen(self):
        print(f"Hallo! Ich bin der Schüler {self.name} und gehe in die Klasse {self.schulklasse}.")

# Wir erstellen Objekte beider Klassen

person1 = Person("Dirk", 53)
schueler1 = Schueler("Max", 16, "10b")

# Rufe die gleiche Methode auf, die sich aber anders verhält

person1.vorstellen()
schueler1.vorstellen()

Die Ausgabe wäre:

Code:

Hallo, mein Name ist Dirk und ich bin 53 Jahre alt.
Hallo! Ich bin der Schüler Max und gehe in die Klasse 10b.

   

Du siehst, wie die gleiche Methode (vorstellen()) in beiden Klassen unterschiedliche Ausgaben erzeugt. Das ist Polymorphie!

Ein weiterer wichtiger Begriff: Kapselung (Encapsulation)

Kapselung ist die dritte Säule der OOP. Es bedeutet, dass die Daten (Attribute) eines Objekts "privat" bleiben und nur durch seine eigenen Methoden verändert werden können. So schützt du die Daten vor versehentlichen Änderungen. In Python wird dies oft durch ein führendes Unterstrichzeichen (_) im Namen des Attributs signalisiert.

Herzlichen Glückwunsch! Du hast die wichtigsten Grundprinzipien der objektorientierten Programmierung gemeistert.

In der nächsten Lektion werden wir alle Konzepte in einem kleinen, praktischen Projekt anwenden.

<< Zurück zur Kurs-Übersicht: Was ist Python und warum du es lernen solltest

[computerdirk]

Ergänzung zu Teil 15: Kapselung im Detail

Hallo zusammen,

da das Thema Kapselung so wichtig ist, möchte ich es noch einmal genauer erklären.

Was bedeutet Kapselung?

Kapselung ist das Prinzip, die internen Daten eines Objekts zu schützen und nur über öffentliche Methoden zugänglich zu machen. Stell dir das wie bei einem Auto vor: Du kannst über das Lenkrad und die Pedale (öffentliche Methoden) fahren, aber du greifst nicht direkt in den Motor (interne Daten) ein.

Kapselung in Python

In Python gibt es keine echten privaten Attribute, aber es gibt Konventionen, die wir nutzen, um anderen Entwicklern zu signalisieren, dass ein Attribut privat ist.

• Einfacher Unterstrich _: Dies ist die gängigste Konvention. Ein Attribut, dessen Name mit einem einzigen Unterstrich beginnt, wie z. B. _name, sollte nicht direkt von außen aufgerufen werden.
  
• Zwei Unterstriche __: Zwei führende Unterstriche sorgen dafür, dass Python den Attributnamen verändert. Dies macht es sehr viel schwieriger, versehentlich auf die Variable zuzugreifen, aber es ist nicht unmöglich.
  

Wie du Kapselung anwendest (Getter und Setter)

Um die privaten Daten zu schützen, schreibst du öffentliche Methoden, um sie zu lesen (sog. Getter) und zu ändern (sog. Setter).

Beispiel mit unserer Person-Klasse:

Code:

class Person:
    def __init__(self, name, alter):
        self._name = name  # Das Attribut ist "privat"
        self._alter = alter

    # Getter-Methode, um den Namen zu lesen
    def get_name(self):
        return self._name

    # Setter-Methode, um den Namen zu ändern
    def set_name(self, neuer_name):
        if len(neuer_name) > 0:
            self._name = neuer_name
        else:
            print("Name kann nicht leer sein!")

# Jetzt kannst du auf das Objekt zugreifen
person1 = Person("Dirk", 42)

# Wir lesen den Namen über die Methode, nicht direkt!
print(person1.get_name())

# Wir ändern den Namen über die Methode
person1.set_name("Max")
print(person1.get_name())

# So schützt du deine Daten vor unsinnigen Werten
person1.set_name("")

Wie du siehst, gibt dir die Kapselung die volle Kontrolle über deine Daten.