Kids' Programming Language
Inhalt

Sprachreferenz

Klassen erweitern (Vererbung)*

Klassen erweitern

Eine der wichtigsten Konzepte der so genannten objektorientierten Programmierung ist die Möglichkeit bereits vorhandene Klassen zu erweitern. Statt eine Klasse völlig neu zu programmieren, kann man auf Klassen zurückgreifen, die schon einen Teil der gewünschten Funktionalität bereit stellen. Anders ausgedrückt lässt sich eine vorhandene Klasse spezialisieren oder "ableiten". Die abgeleitete Klasse "erbt" die Methoden der vorhandenen Klasse, der so genannten "Elternklasse", und kann eigene Methoden hinzufügen.

Als Beispiel soll die Klasse 'Kreis' so erweitert werden, dass statt der 'Größe' des Kreises (also des Durchmessers) der Parameter 'Radius' verwendet werden soll. Außerdem sollen sich die Koordinaten der  Methode 'zeige' auf die obere linke Ecke und nicht auf den Mittelpunkt des Kreises beziehen. Ohne die Vererbung bliebe nichts weiter übrig als eine Klasse 'RadiusKreis' zu schreiben mit allen Methoden. Eine bessere Möglichkeit bietet die Erweiterung der vorhandenen Klasse 'Kreis'. Um eine Klasse zu erweitern schreibt man nach dem gewünschten Namen der (spezialisierten) Klasse das Schlüsselwort 'erweitert' gefolgt von dem Namen der Elternklasse 'Kreis':
 
Programm

RadiusKreis erweitert Kreis

 
Objekte von der Klasse 'RadiusKreis' lassen sich wie gewohnt erzeugen. Da 'RadiusKreis' die Methoden von der Klasse 'Kreis' erbt, lässt sich auch wie gewohnt die Methode 'zeige' aufrufen:
 
Programm
MeinKreis=RadiusKreis()
zeige(x=0,y=0):MeinKreis
RadiusKreis erweitert Kreis

 
Im Klassen-Browser erscheint unter der Klasse 'RadiusKreis' Liste der "geerbten" Methoden der Elternklasse 'Kreis'. Man beachte, dass in diesem Fall keine Parameter wie 'Größe' oder 'Farbe' beim Erzeugen des Kreises erlaubt sind. Diese Parameter müssen (wie gewohnt) nach dem Namen der Klasse angegeben werden. Für Klasse 'RadiusKreis' sollte es einen Paramter 'Radius' geben und außerdem sollte man die 'Farbe' des Kreises bestimmen können! Diese Paramter können (müssen aber nicht) benutzt werden, um die Paramter der Elternklasse 'Kreis' zu bestimmen. In unserem Fall setzen wir den Parameter der Elternklasse 'Größe' gleich dem doppeltem Wert des Parameters 'Radius' und "leiten" den Parameter 'Farbe' zur Elternklasse 'Kreis' weiter. Objekte der Klasse 'RadiusKreis' lassen sich nun folglich mit den Paramtern 'Radius' und 'Farbe' erzeugen.
 
Programm
MeinKreis=RadiusKreis(Radius=200)
zeige(x=0,y=0):MeinKreis
RadiusKreis(Radius=50,Farbe="grün") erweitert Kreis(Größe=2*Radius,Farbe=Farbe)

 
In die Klasse 'RadiusKreis' lassen sich jetzt weitere Methoden einfügen (wie zum Beispiel eine Methode 'gibRadius'), die die Klasse 'Kreis' um neue Funktionalitäten erweitert:
 
Programm
MeinKreis=RadiusKreis(Radius=200)
zeige(x=0,y=0):MeinKreis
schreibe:"Der Radius von MeinKreis ist "+ gibRadius:MeinKreis +"."
RadiusKreis(Radius=50,Farbe="grün") erweitert Kreis(Größe=2*Radius,Farbe=Farbe)
schreibe:"Radius: "+Radius
schreibe:"Durchmesser: "+(2*Radius)
schreibe:"Farbe: "+Farbe

Methode gibRadius=Radius

 
Als letztes soll die Klasse so verändert werden, dass sich die Koordinaten der  Methode 'zeige' auf die obere linke Ecke und nicht mehr auf den Mittelpunkt des Kreises beziehen. Es lässt sich die Methode 'zeige' der Elternklasse 'Kreis' zwar nicht direkt ändern, wohl aber durch eine eigene Methode 'zeige' "überdecken" die sich in der Klasse 'RadiusKreis' befindet. Wird im Programm 'zeige:MeinKreis' aufgerufen, so wird dann die Methode 'zeige' der Klasse 'RadiusKreis' und nicht mehr der Klasse 'Kreis' ausgeführt. Das gilt auch, falls die Methode durch z.B. 'zeige(x=x+Radius,y=y+Radius)' innerhalb der Klasse 'RadiusKreis' aufgerufen wird.

Da aber die Methode 'zeige' der Elternklasse zum Zeichnen des Kreises benötigt wird, stellt uns das vor ein Problem. Abhilfe schafft der '~'-Operator, der vor den Methodennamen gestellt die entsprechende Methode der Elternklasse aufruft. Mit der Anweisung '~zeige' wird folglich die Methode 'zeige' der Klasse 'Kreis' aufgerufen. Vervollständigt sieht das Programm dann folgendermaßen aus:
 
Programm
MeinKreis=RadiusKreis(Radius=200,Farbe="orange")
zeige(x=0,y=0):MeinKreis
RadiusKreis(Radius=50,Farbe="grün") erweitert Kreis(Größe=2*Radius,Farbe=Farbe)
%Beziehe Koordinaten of obere linke Ecke des Kreises:
x=400-Radius
y=300-Radius

Methode gibRadius=Radius

Methode zeige(x=x,y=y)
%Beziehe Koordinaten of obere linke Ecke des Kreises:
~zeige(x=x+Radius,y=y+Radius)
 
Wird ein '~'-Zeichen vor einen Methodennamen gestellt, so muss die Methode in der Elternklasse (oder in der Elternklasse der Elternklasse usw.) existieren. Existiert die Methode nur in der abgeleiteten Klasse, so kommt es zu einer Fehlermeldung. Außerdem ist die Verwendung von außerhalb, also zum Beispiel '~zeige:MeinKreis' in der Klasse 'Programm', unzulässig.

Virtuelle Methoden und Benutzereingaben

Es ist nun bekannt wie ein abgeleitete Klasse Methoden ihrer Elternklasse aufruft, doch wie kann eine Elternklasse eine Methode der abgeleiteten Klasse aufrufen und ist das überhabt sinnvoll? Betrachten wir die Klasse 'Fenster', die ein Fenster anzeigen und wieder entfernen sowie auf Benutzereingaben wie Maus- und Tastaturaktionen reagieren kann. Beim Start eines KidsPL-Programms wird sogar standardmäßig ein Objekt der Klasse 'Fenster' erzeugt und die Methode 'zeige' aufgerufen. Deswegen erscheint ein KidsPL-Programm immer in einem Fenster. Die einzige Ausnahme von der Regel tritt ein, wenn die Klasse 'Programm' von der Klasse 'Fenster' abgeleitet (erweitert) wird. In diesem Fall kann man insbesondere selbst steuern, ob und wann ein Fenster angezeigt werden soll.

Die Klasse 'Fenster' ruft zum Beispiel immer, wenn eine Maustaste gedrückt wird, ihre Methode 'wennMausGedrückt' auf. Diese Methode ist aber keine normale Methode, sondern ist 'virtuell'. Das bedeutet, dass eine Methode aus der abgeleiteten Klasse mit dem selben Namen die Methode nicht nur "überdeckt" sondern "überschreibt". Das hat den Effekt, dass die Methode 'wennMausGedrückt' der abgeleiteten Klasse, falls diese existiert, aufgerufen wird, falls eine Maustaste gedrückt wird. Falls die Methode nicht virtuell wäre, würde immer die Methode 'wennMausGedrückt' der Elternklasse und nicht die Methode der abgeleiteten Klasse 'Fenster' aufgerufen (auch wenn die Methode der abgeleiteten Klasse nach außen hin die Methode der Elternklasse "überdeckt"). Parameter der virtuelle Methode können (müssen aber nicht) benutzt und um eigene Paramter ergänzt werden. Die Methode 'wennMausGedrückt' übergibt zum Beispiel die Zahl-Paramter 'x', 'y' und 'Taste'. Ein Programm, dass an jeder Stelle des Fensters, an der eine Maustaste gedrückt wird, einen Kreis zeichnet, sieht zum Beispiel folgendermaßen aus:
 
Programm erweitert Fenster
zeige(Titel="Mein Programm")

Methode wennMausGedrückt (x=0,y=0)
zeige(x=x,y=y):Kreis(Größe=20)
 
Wie man auf andere Benutzereingaben reagieren kann, lässt sich der Klassenreferenz zu Fenster entnehmen.

Jetzt kostenlos herunterladen.
Diese Seite ausdrucken.
Diese Seite speichern.