4 Eigene Methoden zum Steuern einer Turtle
4.1 Wie schreibt man eine Methode?
 
  In Kap. 3.1.1 haben wir die for-Schleife kennen gelernt. Mit Hilfe dieser Technik konnten wir das Zeichnen eines Quadrats sehr effizient programmieren.

for (int i=0;i<4;i++){
   t1.forward(100);
   t1.right(90);
}

Lästig ist es aber, wenn man in einem Programm mehrere Quadrate zeichnen lassen möchte. Da wäre es geschickt, wenn man das Zeichnen des Quadrats nur einmal implementieren müsste. Dies kann man tatsächlich tun, indem man eine Methode zeichneQuadrat(...) in der Klasse Quadrat1 schreibt. Schauen wir uns an, wie das geht:
 

Download:
Quadrat1.java
import turtle.*;
import java.awt.*;

public class Quadrat1 extends TurtleFrame {
    Turtle t1;

    public Quadrat1(String title) {
        super(title);
        t1 = new Turtle(tWin);
    }

    public void zeichneQuadrat(Turtle t){
      for(int i = 0; i < 4; i++){        
        t.forward(100);                  
        t.right(90);                     
      }                                  
    }                                    

    public void zeichne() {
      zeichneQuadrat(t1);
    }

    public static void main(final String[] args) {
        new Quadrat1("Quadrat");
    }
}
Bemerkungen zum Quelltext In der Klasse Quadrat1 ist eine Methode zeichneQuadrat(Turtle t) implementiert. Sie ist gelb markiert und sie wird in der zeichne()-Methode aufgerufen (hellblau markiert). Beschäftigen wir uns zunächst mit dem Methodenaufruf. Er erfolgt ohne Punktnotation, weil die Methode in der Klasse implementiert ist, in der auch der Aufruf erfolgt. Da es in einem Programm mehrere Turlte-Objekte geben kann, müssen wir beim Methodenaufruf auch sagen, wer das Quadrat zeichnen soll. In unserem Fall ist es das Turtle-Objekt t1. Dass wir so vorgehen können, garantiert uns die Art und Weise, wie die Methode programmiert wurde. Befassen wir uns jetzt mit der Methode selbst. Sie hat natürlich den Namen, mit dem wir sie aufrufen wollen. Für Methodennamen gelten einige Regeln, die wir einhalten wollen, so schreiben wir Methodennamen immer klein. Um einen längeren Methodennamen besser lesen zu können, streuen wir Großbuchstaben eein. Das machen wir besonders gerne, wenn der Methodennamen aus mehreren Wörtern besteht. Dem Methodennamen sind die Javawörter public und void (in dieser Reihenfolge) vorgestellt. Das Wort public bedeutet dabei, dass die Methode öffentlich ist und von anderen benutzt werden kann. Das Wörtchen void besagt, dass die Methode an ihren Aufrufer keine Meldung zurückgibt. Die Methode ist somit ähnlich aufgebaut, wie die zeichne()-Methode auch. Die Parameterliste, sie ist an den runden Klammern erkennbar, ist nicht leer. In ihr steht, dass ein Wert, genauer ein Objekt übergeben werden muss. In unserem Fall handelt sich um ein Turtle-Objekt, weshalb auch Turtle als erstes Wort in der Liste auftaucht. Nun muss man noch festlegen, unter welchem Namen man innerhalb der neuen Methode auf dieses Objekt zugreifen möchte, hier ist es t. Wir sehen also, in der Parameterliste wird das Objekt t definiert, aber nicht initialisiert. Einen Verweis auf ein konkretes Objekt erfolgt erst beim Aufruf der Methode. Nun sind wir fast fertig, wir schreiben nur noch in den Rumpf der Methode, was t tun soll, wenn die Methode aufgerufen wird, nämlich das Quadrat zeichnen.
 
Mehrfacher Aufruf Es ist offensichtlich, dass die Implementierung der Methode nur einen Sinn macht, wenn die Methode mehrfach aufgerufen wird. Wie das geht, zeigt das nächste Beispiel: Quadrat2.
 
Download:
Quadrat2.java
import turtle.*;
import java.awt.*;

public class Quadrat2 extends TurtleFrame {
    Turtle t1, t2;

    public Quadrat2(String title) {
        super(title);
        t1 = new Turtle(tWin);  
        t1.setColor(Color.BLUE);
        t2 = new Turtle(tWin);  
        t2.setColor(Color.RED); 
    }

    public void zeichneQuadrat(Turtle t){
      for(int i = 0; i < 4; i++){
        t.forward(100);
        t.right(90);
      }
    }

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

    public static void main(final String[] args) {
        new Quadrat2("Quadrat");
    }
}
Bemerkungen Wir deklarieren zwei Turtle-Objekte t1 und t2. Im Konstruktor unserer Klasse werden die Objekte erzeugt und ihre Farben gesetzt. In der
zeichne()
-Methode werden die beiden Objekte auf die Punkte (-150/-150) bzw. (30/30) gesetzt, bevor sie beim Aufruf von zeichneQuadrat(...) der Methode übergeben werden. Beim ersten Aufruf der Methode zeichneQuadrat(turtle t) erhält t einen Verweis (wir sagen gerne Referenz) auf t1 und somit zeichnet t1 das Quadrat. Beim zweiten Aufruf der Methode, jetzt wird t2 übergeben, erhält t eine Referenz auf t2, weshalb t2 das Quadrat zeichnet.
 


 

Modifizierte Methode Was ist nun, wenn die beiden Turtle-Objekte unterschiedlich große Quadrate zeichnen soll? Müssen wir dann zwei verschiedene Methoden schreiben? Nein, Methoden können sehr flexibel gestaltet werden. Das nächste Beispiel zeigt einen Weg.
 
Download:
Quadrat3.java
public void zeichneQuadrat(Turtle t, double laenge){
  for(int i = 0; i < 4; i++){
    t.forward(laenge);
    t.right(90);
  }
}
  Wir definieren in der Parameterliste eine weitere Größe fest, nämlich laenge, sie ist vom Typ double. Ihr Wert wird wieder erst beim Aufruf der Methode durch Übergabe festgelegt:
 
 
public void zeichne() {
  t1.jumpTo(-150,-150);
  zeichneQuadrat(t1,100);
  t2.jumpTo(30,30);
  zeichneQuadrat(t2,50);
}
  Beim ersten Aufruf der Methode wird eine Referenz auf t1 und für die Länge der Wert 100 übergeben. Beim zweiten Aufruf sind es eine Referenz auf t2 und die Länge 50. In Kapitel 4.3 wird gezeigt, wie man einmal geschriebene Methoden in verschiedenen Programmen benutzen kann, sie also nicht immer wieder neu schreiben muss.
 
zu 4.2 Übungen
zur Startseite www.pohlig.de  (C) MPohlig 2007