Wenn wir bisher ein Programm geschrieben haben, war der Ansatz „prozedural“ oder „imperativ“, d.h. wir haben uns überlegt, aus welchen Einzelschritten ein Algorithmus besteht und haben dann ein Programm erstellt, welches diese Schritte durchgeführt hat. Mithilfe von Funktionen kann man ein solches Programm strukturieren und Redundanz vermeiden.

Die objektorientierte Programmierung geht von einem anderen Ansatz aus: Ein Programm besteht nicht aus einem Ablauf von Anweisungen und Funktionen, sondern aus Objekten. Diese Objekte haben bestimmte Eigenschaften und Methoden und sie stehen miteinander in Verbindung. Oftmals wird das Programm dann durch Events gesteuert (z.B. Tastaturanschläge, Mausklicks etc.).

Definition einer Klasse und eines Objektes in Python

class Auto(): # eine Klasse Auto definieren
    pass

Ferrari = Auto() # ein neues Auto-Objekt erzeugen

Instanzattribute vs. Klassenattribute und Instanzmethoden vs. Klassenmethoden

Man muss nun unterscheiden, ob eine Eigenschaft zu einem konkreten Objekt gehört (Instanzattribut, Instanzvariable), oder ob sie für die gesamte Klasse gleich bleibt (Klassenattribut, Klassenvariable). Bei der Klasse Auto könnte man z.B. das Klassenattribut Anzahl_Raeder haben. Da dies für alle Objekte der Klasse Auto gleich sein wird (4) und nicht vom konkreten Objekt abhängt, muss es nur einmal unter der KLasse Auto gespeichert werden.

Die Attribute Kilometerstand,Tankfuellung, MaxSpeed, Verbrauch etc. wären Instanzattribute, sie gehören zu einer bestimmten Instanz und beschreiben ein konkretes Objekt.

Genauso ist es bei den Methoden (Funktionen): Instanzmethoden verwenden Instanzvariablen und sind deshalb an ein konkretes Objekt gebunden. Klassenmethoden hingegen hängen nicht vom konkreten Objekt ab, sondern nur von der Klasse und dürfen somit auch nicht auf die Instanzattribute zugreifen. Man kann sich z.B. eine Hilfsfunktion steuerwert vorstellen, welche den Startwert des Autos und das aktuelle Alter des Autos als Parameter übernimmt und dann den aktuellen Steuerwert berechnet. Dies könnte man als Klassenmethode implementieren. Man könnte natürlich auch die Instanzvariablen startwert und alter einführen, auf welche die Funktion steuerwert zugreift - dann wäre die Methode steuerwert eine Instanzmethode.

class Auto():
    
    anzahl_Raeder = 4
    
    def __init__(self, ps, km, tank, verbrauch, maxspeed,alter, neupreis):
        self.PS = ps
        self.Kilometerstand = km
        self.Tankfuellung = tank
        self.MaxSpeed = maxspeed
        self.Verbrauch = verbrauch
        self.Alter = alter
        self.Neupreis = neupreis
    
    def tanken(self, liter):
        self.Tankfuellung = self.Tankfuellung + liter
    
    def fahren(self, km):
        self.Kilometerstand += km
        self.Tankfuellung = self.Tankfuellung - km * self.Verbrauch/100
    
    def steuerWert2(self):
        return self.Neupreis*0.8**self.Alter
    
    @classmethod
    def steuerwert(cls, neupreis, alter):
        return neupreis* (0.8**alter)
    
    
Ferrari = Auto(550,0,40,14,300,0,200000)
VW = Auto(103, 87987, 38, 7, 145,4,26000)

Ferrari.fahren(30)
print(Ferrari.Kilometerstand)

print("VW Steuerwert:" + str(Auto.steuerwert(26000, 4)))
print(VW.steuerWert2())

class Objekt():
    yPos = (-1)*60 # kleiner Trick, um Minecraft zu überlisten (-60)
    def __init__(self, x, z): # jedes Objekt hat eine x- und z-Position
        self.xPos = x 
        self.zPos = z

    def baue(self):  # wird in der Kindklasse überschrieben
        pass 


class Haus(Objekt): # Haus erbt von Objekt
    def __init__(self, x, z, b, h):
        super().__init__(x, z)  # Konstruktor der Elternklasse aufrufen
        self.__breite = b # private Variablen
        self.__hoehe = h

    def getBreite(self):  # Getter-Methode
        return self.__breite
    
    def setBreite(self, b):  # Setter-Methode
        if b > 30:
            player.say("zu breit, sorry")
        else: 
            self.__breite = b
    
    def baue(self): # Die Methode 'baue' wird überschrieben
        blocks.fill(CONCRETE,world(self.xPos, -61, self.zPos), world(self.xPos+self.__breite, -61+self.__hoehe, self.zPos+self.__breite),FillOperation.HOLLOW)
        for xPos1 in range(self.xPos+2, self.xPos+self.__breite, 3):
            for hoehe1 in range(-61+3, -61+self.__hoehe, 4):
                blocks.place(GLASS, world(xPos1, hoehe1, self.zPos))
                blocks.place(GLASS, world(xPos1, hoehe1, self.zPos+self.__breite))
        for zPos1 in range(self.zPos+2, self.zPos+self.__breite, 3):
            for hoehe1 in range(-61+3, -61+self.__hoehe, 4):
                blocks.place(GLASS, world(self.xPos, hoehe1, zPos1))
                blocks.place(GLASS, world(self.xPos+self.__breite, hoehe1, zPos1))
        
        # Loch für Türe
        blocks.place(AIR, world(self.xPos+2, -60, self.zPos))
        blocks.place(AIR, world(self.xPos+2, -59, self.zPos))
        # Türe
        blocks.place(blocks.block_with_data(CRIMSON_DOOR, 4),world(self.xPos+2, -60, self.zPos))      

    def loesche(self):
        blocks.fill(AIR,world(self.xPos, -61, self.zPos), world(self.xPos+self.__breite, -60+self.__hoehe, self.zPos+self.__breite))
        blocks.fill(GRASS, world(self.xPos, self.yPos-2, self.zPos),world(self.xPos+self.__breite, self.yPos-1, self.zPos+self.__hoehe))

Hauser = []

Haus1 = Haus(200,200,10,6)
Haus1.baue()
player.say(Haus1.xPos) #xPos ist in der Elternklasse definiert, wurde aber vererbt.
# player.say(Haus1.__breite)  geht nicht, da breite private ist
player.say(Haus1.getBreite()) # die Breite mit der Getter-Methode holen

Objektorientierte Programmierung auf python-kurs.eu

OOP Tech with Tim