10 Eigene Methoden
10.1 Die Klasse MeineTurtle erbt von Turtle
 
drei Mal ein Quadrat Wir wollen noch einmal unsere Turtle ein Quadrat zeichnen lassen. Und zwar soll das ganze Quadrat gezeichnet werden, wenn man einmal auf den Zeichne!-Schalter klickt. Es bieten sich drei Möglichkeiten an. Die erste besteht darin, dass wir die Turtle Schritt für Schritt das Quadrat abschreiten lassen:

Die dazu gehörige Methode zeichne() hat die folgende Gestalt.

public void zeichne() {
   t1.jumpTo(-150,50);
   t1.forward(100);
   t1.right(90);
   t1.forward(100);
   t1.right(90);
   t1.forward(100);
   t1.right(90);
   t1.forward(100);
   t1.right(90);
}

Um unnötigen Quellkode zu vermeiden, können wir eine Schleife benutzen. Der neue Kode der zeichne()-Methode sieht dann so aus:

public void zeichne() {
   t1.jumpTo(-150,50);
   for (int i=0;i<4;i++){
      t1.forward(100);
      t1.right(90);
   }
}

Noch viel besser wäre es allerdings, könnten wir die Turtle positionieren und ihr einfach 'sagen': Zeichne ein Quadrat. Die zeichne()-Methode könte dann so aussehen:

public void zeichne() {
   t1.jumpTo(-150,50);
   t1.zeichneQuadrat();
}
Was sagt die Turtle-Dokumentation? Ein Blick in die Turtle Dokumentations-API muss uns enttäuschen. Eine Methode zeichneQuadrat() steht in unserer Klasse Turtle nicht zur Verfügung. Wie müsste sie denn gebaut sein. Ein Vergleich mit anderen Methoden legt es uns nahe:

public void zeichneQuadrat()

Und was soll sie genau tun? Nun, sie soll eine Turtle dazu veranlassen, dort wo sie sich befindet ein Quadrat (mit einer Seitenlänge von z-B. 100 Pixel) zeichnen und zwar soll sie zuerst in die Richtung marschieren, in die unsere Turtle gerade zeigt.
 

Die Klasse MeineTurtle Einfach wäre es, uns stünde der Quelltext der Turtle zur Verfügung und wir könnten zu den schon in der Klasse Turtle unsere gewünschte Methode zu den bereits vorhanden hinzufügen. Nun ist uns vom 'Hersteller' der Turtle aber gerade dies untersagt. Er möchte nicht, dass wir in seinem Handwerk 'herumpfuschen'. Java berücksichtigt dies und gibt uns die Möglichkeit eine Klasse zu schreiben, die alle Eigenschaften der Klasse Turtle von dieser übernimmt und weiter uns erlaubt, unsere eigene Ideen hinzuzufügen. Dies ist nicht einmal sehr schwer. Das Konzept, das  Java uns hierzu zur Verfügung stellt, heißt Vererbung. Wie eine Klasse MeineTurtle von der Klasse Turtle erbt wollen wir uns jetzt anschauen:
 

 

import turtle.*;
public class MeineTurtle extends Turtle{
   public MeineTurtle(TurtleWindow tWin){
      super(tWin);
   }
}
  In der zweiten Zeile finden wir das Javawort extends. Es sagt, dass die Klasse, die wir gerade schreiben, von einer anderen Klasse erbt. Und vom wem Sie erbt, steht dahinter. Die Klasse Turtle, von der wir erben wollen, liegt in dem Paket turtle. Damit der Compiler sie findet, teilen wir ihm hinter dem Wort import den Namen dieses Paketes mit. Jetzt kommt noch ein zweiter wichtiger Schritt. Wir erinnern uns, wenn wir eine Turtle t1 erzeugt haben, haben wir in der Zeile

t1 = new Turtle(tWin);

den Konstruktor Turtle(TurtleWindow tWin) benutzt (vgl. hauch hierzu die Dokumentation der Turtle). In unserer Klasse schreiben wir nun einen eigenen Konstruktor, der ist aber sehr einfach:

   public MeineTurtle(TurtleWindow tWin){
      super(tWin);
   }

Der Konstruktor heißt wie die Klasse zu der er gehört und wird auch genauso geschrieben. Neu ist die Zeile super(tWin); Diese Zeile ist einfach aber sehr wichtig. Mit ihr wird nämlich der Konstruktor der Klasse aufgerufen, von dem wir erben, also der Konstruktor von Turtle. Damit sind wir fast fertig, denn unsere Klasse kann alles was auch die Klasse Turtle kann. Wir müssen jetzt nur noch dafür sorgen, dass die Klasse MeineTurtle über eine Methode zeichneQuadrat() verfügt. Wie das geht zeigt der nachstehende Kode.
 

Download:
MeineTurtle.java
import turtle.*;
public class MeineTurtle extends Turtle{
   public MeineTurtle(TurtleWindow tWin){
      super(tWin);
   }
   public void zeichneQuadrat(){
      for(int i=0; i<4;i++){
         forward(100);
         right(90);
      }
   }
}
  Der Quelltext MeineTurtle.java lässt sich compilieren, starten lässt sich das Programm dagegen nicht, das sollte uns aber nicht verwundern. Denn unsere Klasse beschreibt ja nur, was eine Turtle jetzt kann, aber was sie konkret tut, wenn wir wir den 'Zeichne!'-Schalter drücken, ist ja noch nicht programmiert. Das schauen wir uns jetzt noch an.
 
Download:
Quadrate1.java
import turtle.*;
import java.awt.*;

public class Quadrate1 extends TurtleFrame {
  MeineTurtle t1, t2;
  public Quadrate1(String title) {
    super(title);
    t1 = new MeineTurtle(tWin);
    t1.setColor(Color.RED);
    t2 = new MeineTurtle(tWin);
    t2.setColor(Color.BLUE);
  }

  public void zeichne() {
    t1.jumpTo(-150,50);
    t1.zeichneQuadrat();
    t2.jumpTo(50,-150);
    t2.zeichneQuadrat();
  }

  public static void main (String[] args) {
    new Quadrate1("Quadrate - Vers. 1");
  }
}
  Das Programm erzeugt beim Klicken auf den 'Zeichne!'-Schalter ein rotes Quadrat im linken oberen Bereich und ein blaues im rechten unteren.  Zur Erstellung des Quelltextes benutzen wir wieder unsere Vorlage, müssen aber einige kleine Korrekturen vornehmen. So sind  t1 und t2 jetzt keine Objekte mehr von Turtle sondern von MeinTurtle (wichtig: die Klasse MeineTurtle liegt im gleichen Verzeichnis wie Quadrate1.java). Die Änderungen sind im oben dargestellten Quelltext gelb unterlegt. In der Methode zeichne() können wir nun die Methode zeichneQuadrat() aufrufen (grün unterlegt).
 
zu 10.2 Eine bessere zeichneQuadrat-Methode
zur Startseite www.pohlig.de  (C) MPohlig 2003