oop

16. OBJEKTORIENTIERTE PROGRAMMIERUNG (OOP)

 

 

DU LERNST HIER...

 

dass die objektorientierte Programmierung (OOP) ein Programmierkonzept ist, das in vielen Fällen hervorragend geeignet ist, um die reale Welt als Software zu modellieren. So wie du beispielsweise eine lebende Schildkröte als ein bestimmtes Lebewesen einer Tierklasse auffasst, ist eine Turtle in der Turtlegrafik ein bestimmtes Objekt der Softwareklasse Turtle.

 

 

TURTLE-OBJEKTE
 

Damit die Turtle ein Zuhause hat, erzeugst du zuerst ein Objekt der Klasse TurtleFrame mit dem Namen tf. Dazu rufst du die Funktion TurtleFrame() auf, die gleich heisst wie die Klasse selbst. Dabei erscheint auf dem Bildschirm ein Turtlefenster.

tf = TurtleFrame()

Man nennt diese Funktion den Konstruktor der Klasse TurtleFrame. Analog erzeugst du mit dem Konstruktor der Klasse Turtle ein Turtleobjekt tia, verwendest aber tf als Parameter, damit tia ins Turtlefenster gesetzt wird.

tia = Turtle(tf)

Ganz wie in der realen Welt besitzt ein Softwareobjekt bestimmte Eigenschaften und Fähigkeiten. Beispielsweise ein Turtleobjekt:

Eigenschaften   Fähigkeiten
  Turtlefarbe
  Blickrichtung
  Ort
 
  forward(n)
  left(w)
  right(w)

Mit dem Namen des Objekts kannst du auf die Eigenschaften und Fähigkeiten des Objekts zugreifen, indem du den Punktoperator verwendest. Um beispielsweise tia vorwärts laufen zu lassen, rufst du die Funktion

tia.forward(100)

auf. Statt Funktion sagt man bei Objekten auch oft Methode. Für das Turtleobjekt stehen dir alle Methoden zur Verfügung, die du bereits aus der Turtlegrafik kennst.

 

 

MUSTERBEISPIELE

 

Im ersten Beispiel lässt du zwei Turtles tia und joe quasi miteinander einen Stern zeichnen.

from gturtle import *

tf = TurtleFrame()
tia = Turtle(tf)
joe = Turtle(tf)

tia.right(90)
joe.left(90)
repeat 5:
    tia.forward(100)
    joe.forward(100)
    tia.right(144)
    joe.left(144)
► In Zwischenablage kopieren 		 



Um die Turtlefarbe zu setzen, verwendest du einen zusätzlichen Parameter im Konstruktor der Turtle, um die Strichfarbe zu setzen, verwendest du die Methode setPenColor(). Im folgenden Programm zeichnen die grüne tia und der rote joe gleichzeitig eine grüne und eine rote Spirale.

 

   


from gturtle import *

tf = TurtleFrame()
tia = Turtle(tf, "green")
tia.setPenColor("green")
joe = Turtle(tf, "red")
joe.setPenColor("red")

s = 200
while s > 5:
    tia.forward(s)
    joe.forward(s)
    tia.left(90)
    joe.right(90)
    s -= 10
► In Zwischenablage kopieren


Richtig lustig wird es, wenn du das TurtleFrame mit vielen Turtles bevölkerst, die du mit einem Mausklick erzeugst und die nach ihrer Entstehung einen gefüllten Stern zeichnen.

In diesem Beispiel werden die grossen Vorteile der OOP offensichtlich, denn jedes neue Turtleobjekt weiss von sich aus, wie es sich benehmen muss.

 

   


from gturtle import *

def onMouseHit(x, y):
    t = Turtle(tf)
    t.setPos(x, y)
    star(t)

def star(t):
    t.startPath()
    repeat 4:
        t.forward(100)
        t.left(144)
    t.fillPath()

tf = TurtleFrame(mouseHit = onMouseHit)
► In Zwischenablage kopieren

 

 

ANIMATIONEN MIT MEHREREN AKTOREN
 

Brauchst du für eine Animation mehrere Aktoren, so kannst du  mehrere Turtleobjekte erzeugen und jedem davon ein eigenes Animationsbild zuordnen. Du bewegst im folgenden Programm das rosa Pony von rechts nach links und das blaue Pony gleichzeitig von links nach rechts. Damit das blaue Pony in der richtigen Lage erscheint, musst du sein Bild vertikal spiegeln. Das machst du mit zwei zusätzlichen booleschen Parametern in drawImage(), die man wie folgt verwenden kann:

 drawImage(img, False, False)  keine Spiegelung
 drawImage(img, True, False)  horizontale Spiegelung
 drawImage(img, False, True)  vertikale Spiegelung
 drawImage(img, True, True)  horizontale und vertikale Spiegelung

 

from gturtle import *

tf = TurtleFrame()
tia = Turtle(tf)
tia.ht()
tia.setPos(250, 0)
tia.left(90)
tia.wrap()
img_tia = [0] * 8
for i in range(8):
    img_tia[i] = "sprites/pony_" + str(i) + ".gif"

joe = Turtle(tf)
joe.ht()
joe.setPos(-250, 0)
joe.right(90)
joe.wrap()
img_joe = [0] * 8
for i in range(8):      
    img_joe[i] = "sprites/pony2_" + str(i) + ".gif"   

tf.enableRepaint(False)
repeat:
    for i in range(8):
        tia.drawImage(img_tia[i])
        joe.drawImage(img_joe[i], False, True)
        tf.repaint()
        tf.delay(100)
        tf.clear()
        tia.forward(5)
        joe.forward(5)
► In Zwischenablage kopieren

 

 

MERKE DIR...
 

Klassen fassen in der objektorientierten Programmierung (OOP) Eigenschaften und Fähigkeiten zusammen. Ein Objekt wird durch Aufruf des Konstruktors erzeugt, der den gleichen Namen wie die Klasse, aber eine Parameterklammer hat. Der Rückgabewert des Konstruktors wird einer Variablen zugewiesen, mit der man mittels des Punktoperators auf das Objekt zugreifen kann.

 

 

ZUM SELBST LÖSEN

 
1.

a) Zwei Turtles zeichnen mit dem Befehl dot() von unten nach oben abwechslungsweise eine grüne bzw. eine rote Perle und erzeugen zwei Perlenketten.

b) Die Turtles zeichnen nur eine einzige Perlenkette, die abwechslungsweise eine grüne und eine rote Perle hat.

 
a)
b)


2.

In einem Turtlefenster soll mit jedem Mausklick ein neues Turtleobjekt erzeugt werden, wobei der Turtle das Spritebild spider.png zugeordnet ist:

t = Turtle(tf, "sprites/spider.png")

Jede Turtle dreht zuerst 90° nach rechts und bewegt sich vorwärts. Wenn sie am rechten Rand ankommt (getX() > 300), dreht sie um 180° und läuft wieder zurück. Analog am linken Rand.

  



3.

Erstelle eine endlose Animation mit zwei Ponys, die miteinander laufen.

Verwende die Bilder pony_0.gif,...,pony_7.gif.


  



4.

Verwende die Sprites
person_0.png,. .,person_4.png sowie
tiger_2.gif,...,tiger_6.gif
und erstelle eine endlose Animation, bei der die Person von links nach rechts und der Tiger von rechts nach links laufen.

  


 

 

 

    

 

     

 

16-1
Fachliche Hinweise:

Man kann die beiden Turtle parallel laufen lassen, wenn man für jede einen Thread erzeugt, in dessen run-Methode die Spirale gezeichnet wird. 

from gturtle import *
import thread

def run(t, clockwise):
    s = 200
    while s > 5:
        t.forward(s)
        if clockwise:
            t.right(90)
        else:
            t.left(90)
        s -= 10 

tf = TurtleFrame()
tia = Turtle(tf, "green")
tia.setPenColor("green")
joe = Turtle(tf, "red")
joe.setPenColor("red")
thread.start_new_thread(run, (tia, False))
thread.start_new_thread(run, (joe, True))

 

16-2
Fachliche Hinweise:

Noch eleganter ist es, die Klasse Turtle so zu erweitern, dass ein Objekt die weitere Fähigkeit erhält, einen Stern zu zeichnen. Man definiert dazu eine abgeleitete Klasse StarTurtle, die alle Eigenschaften und Fähigkeiten der Klasse Turtle erbt, aber noch die zusätzliche Methode star() enthält.

from gturtle import *

class StarTurtle(Turtle):
    def __init__(self, tf, x, y):
        Turtle.__init__(self, tf)
        self.setPos(x, y)
        
    def star(self):
        self.startPath()
        repeat 4:
            self.forward(100)
            self.left(144)
        self.fillPath()

def onMouseHit(x, y):
    t = StarTurtle(tf, x, y)
    t.star()

tf = TurtleFrame(mouseHit = onMouseHit)