Beim Objektorientierten Programmieren dreht sich alles – der Name sagt es – um sogenannte Objekte. Im folgenden Beispiel schauen wir als Beispiel nicht die Turtle, sondern ein anderes Tier, nämlich den «Hund» an.

Begriffe #

Klasse	Objekte
«Hund»	«Bitzer»	«Space-Bitzer»
Eigenschaft	Werte
Farbe	Gelb	Space-Blau
Bell-Laut	Wuff!	Beep!
Methoden	belle!, sitz!, hohle Stöckli!, schwimm!, iss!, …

Klasse #

Das wäre hier sozusagen die Tierart «der Hund». Also wenn man so will – eine Vorlage für irgendeinen Hund.

Eigenschaften #

Die Eigenschaften eines Hundes, z.B. seine Farbe oder der Laut den er beim Bellen von sich gibt.
Etwas salopp gesagt handelt es sich Variablen die zum Hund gehören.

Methoden #

Die Fähigkeiten werden mit Hilfe von Methoden ausgedrückt. Was kann ein Hund, z.B. «sitz machen» oder bellen.
Wiederum etwas salopp gesagt sind Methoden Unterprogramme die zum Hund gehören.

Objekt #

Das Objekt wäre der einzelne Hund mit seinen speziellen Eigenschaften und den Methoden. Aus einer Klasse können wir beliebig viele Objekte erzeugen. Diese können sich in ihrem Namen und den Werten der Eigenschaften unterscheiden.
Etwas salopp gesagt ist die Klasse eine Vorlage für das Objekt.

Sowohl Methoden also auch Eigenschaften sind bereits in der Klasse definiert. Das Objekt gibt den Eigenschaften Werte und kann die Methoden ausführen.

eigene Klasse #

Die einfachste Python-Klasse sieht wie folgt aus

class Dog:
    pass

Die Klasse wird mit dem Schlüsselwort class definiert. Sie hat einen Namen (hier Dog). Klassennamen schreibt man zur Unterscheidung von Variablen gross.

Unsere Klasse Dog hat weder Eigenschaften noch Methoden. Ihr einziger Inhalt besteht in der Anweisung pass, die nichts tut, sondern da sein muss, weil Python keine wirklich leeren Klassen zulässt.

Nichtsdestotrotz können wir die Klasse verwenden. Dazu müssen wir diese importieren. Wir nehmen an die Klasse Dog sei in der Datei dog.py im selben Verzeichnis wie untenstehendes Testprogramm abgespeichert. So können wir diese importieren und verwenden:

from dog import Dog

bitzer = Dog()
space_bitzer = Dog()

Zeilen 3 & 4

wir erzeugen ein neue Objekte der Klasse Dog

Methoden #

Methoden werden wie Unterprogramme definiert – allerdings in der Klasse drin. Somit gehören Methoden zum aus der Klasse erzeugten Objekt und haben auch Zugriff auf die Eigenschaften dieses.

class Dog:

    def bark(self):
        print("wau!")

Zeilen 3 & 4

wir definieren die Methode bark

Methoden erhalten immer self als erstes Argument. Damit kann können diese auf das Objekt zugreifen (mehr dazu weiter unten)

Nun können wir nicht nur Hunde erzeugen, sondern auch die Methode bark aufrufen:

from dog import Dog

bitzer = Dog()
bitzer.bark()

Zeile 4

wir rufen die Methode bark auf

Eigenschaften #

Auf die Eigenschaften eines Objektes kann mit der Punktnotation zugegriffen werden:

from dog import Dog

bitzer = Dog()
bitzer.color = "beige"
print(bitzer.color)

Zeile 4

wir setzen die Farbe des Hundes bitzer auf beige

Zeile 5

wir rufen die Farbe des Hundes bitzer auf

Getter und Setter #

Das ist jedoch unschön und man vermeidet wenn immer möglich solche direkten Zugriffe. Eleganter geht der Zugriff mit sogenannten Set- und Get-Methoden.

Als Konvention benennt man diese immer gleich: set resp. get und dann der Name der Eigenschaft in sogenanntem CamelCase^[1].
Dank dem Argument self können alle Methoden auf das eigene Objekt zugreifen.

class Dog:

    def setColor(self, color):
        self.color = color

    def getColor(self):
        return self.color

Nun können wir die Eigenschaft color mittels der Methode setColor festlegen und mittels getColor wieder aufrufen:

from dog import Dog

bitzer = Dog()
bitzer.setColor("beige")
print(bitzer.getColor())

Zeile 4

wir setzen die Farbe des Hundes bitzer auf beige

Zeile 5

wir rufen die Farbe des Hundes bitzer auf

Dank dem indirekten Setzen der Eigenschaften über den Setter können wir durch Überprüfen der Werte nun sicherstellen, dass nur gültige Werte gesetzt werden.

Methoden und Eigenschaften #

Wir können nun die schon zu Beginn verwendete Methode bark anpassen, so dass verschiedene Hunde verschieden bellen:

class Dog:

    def setBarking(self, barking):
        self.barking = barking

    def bark(self):
        print(self.barking)

from dog import Dog

bitzer = Dog()
bitzer.setBarking("wuff!")
bitzer.bark()

Konstruktor #

Oft möchte man gleich beim Erstellen des Objektes gewisse Eigenschaften festlegen, die ev. gar nicht mehr geändert werden sollen.

So ist es ja etwas komisch, dass der Hund die Fähigkeit hat, seine Farbe anzupassen. Wir würden wohl die Farbe besser gleich beim Erzeugen festlegen.

Andere Eigenschaften sollten immer gesetzt werden, z.B. der Bell-Laut der von der Methode bark verwendet wird.

Beides können wir mit der speziellen Methode __init__() – genannt Konstruktor – erreichen. Diese wird beim Erzeugen eines Objektes automatisch aufgerufen. Dabei werden die Argumente direkt übergeben.

class Dog:

    def __init__(self, color):
        self.color = color
        self.barking = "wau!"

    def bark(self):
        print(self.barking)

Ein so erzeugter Hund erhält eine beliebige Farbe und den Standard-Bell-Laut «wau!».

from dog import Dog

bitzer = Dog("beige")
bitzer.bark()

Zeile 3

Beim Erzeugen des Hundes müssen wir jetzt die Farbe als Argument übergeben