5.2 MeineTurtle erbt von Turtle
 
  Schauen wir uns die Umsetzung der im letzten Kapitel aufgezeigten Hierarchie in Java an, bevor wir zur Implementierung von MeineTurtle kommen. 
Klasse A 
public class A {



  Attribute (Variable) von A



  public A(){...}

  

  public A(int i){...}



  Methoden von A

}
  Wie schon die UML-Notation der Klasse A zeigt, besitzt diese drei Attribute, zwei Konstruktoren, die sich in der Signatur, konkreter, in der Parameterliste unterscheiden und schließlich zwei Methoden.
 
Klasse B 
public class B extends A {



  Attribute (Variable) von B



  public B(){...}

  

  Methoden von B

}
  Dass die Klasse B von der Klasse A erben soll, teilen wir dem Kompiler durch das reservierte Wort extends (gelb unterlegt) mit. Die Attribute und Methoden, die B gegenüber A zusätzlich haben soll, werden hinzugefügt. Wie wir Methoden implementieren, lernen wir im nächsten Kapitel. Beschäftigen wir zunächst mit den Konstruktoren.
 
Konstruktoren Als erstes müssen wir wissen, dass jede Klasse einen Konstruktor haben muss. Implementieren wir keinen Konstruktor, so fügt der Kompiler den Standardkonstruktor automatisch hinzu. Er hat die Gestalt

public <Klassenname>(){

}

Scheinbar tut dieser Konstruktor nichts, denn der Anweisungsblock ist leer. Das täuscht aber. Denn jeder Konstruktor ruft automatisch den Standardkonstruktor der Klasse auf, von der man erbt. Und jetzt kommt die wichtige Information: Jede Klasse, die man nicht von einer anderen Klasse mittels extends explizit erben lässt, erbt automatisch von der Object. Diese Klasse steht somit an der Spitze aller Klassen. Auch unsere Klasse A erbt,  nämlich von Object. Ihre Konstruktoren rufen automatisch den Standardkonstruktor von Object nämlich Object() auf und A erbt 11 Methoden (vgl. dazu die Übungen in 5.4).

Jetzt lassen wir die Klasse B von A erben, damit erbt sie nicht mehr direkt von Object (Mehrfachvererbungen sind in Java aus Gründen, die wir noch kennen lernen verboten), trotzdem stehen B alle Eigenschaften der Klasse A zur Verfügung, denn ein Konstruktor von B ruft wegen der Vererbung den Standardkonstruktor von A auf, der seinerseits den Standardkonstruktor von Object aufruft. Was aber,  wenn ich will, dass ein Konstruktor von B nicht den Stndardkonstruktor von A sondern einen anderen aufrufen soll? Das geht einfach. Wir teilen dies explizit im entsprechenden Konstruktor von B mit. Das geht so:

public B(..) {
   super(...);
   ...
}

Wir schreiben in die erste Zeile unseres Konstruktors das reservierte Wort super und in runden Klammern, eine Parameterliste, die zu dem gewünschten Konstruktors in A passt. Damit findet der Kompiler auf jeden Fall den richtigen Konstruktor.
 
Der Konstruktor der Turtle Wir schauen uns den Konstruktor der Turtle an. Wir finden ihn in der Dokumentation der Turtle ausführlich beschrieben.
 
Abb. 5.2.1 Einer der Turtlekonstruktoren
 
  In der ausführlichen Beschreibung erfahren wir, dass mit der Übergabe des tWin-Objekts der Kontext steht, wo die Turtle erzeugt werden soll, also das Zeichenfeld. Ohne dieses Zeichenfeld kann die Turtle nicht existieren. Dieser Tatsache müssen wir Rechnung tragen, wenn wir unsere erweiterte Turtle also MeineTurtle implementieren wollen.
 
MeineTurtle import turtle.*;
public class MeineTurtle extends Turtle{
   public MeineTurtle(TurtleWindow tWin){
      super(tWin);
   }
}
  Wir bauen einen Konstruktor MeineTurtle(...), der dem Konstruktor von A, so wie wir ihn bis jetzt benutz haben, nachgebildet ist. Damit auch der richtige Konstruktor von A aufgerufen wird, heißt die erste Zeile im Anweisungsblock:

super(tWin);

Noch besitzt MeinTurtle keine gegenüber Turtle erweiterte Funktionalität, es fehlen noch die Methoden, die MeineTurtle zusätzlich besitzen soll.
 
zu 5.3 Eigene Methoden in der Klasse MeineTurtle
zur Startseite www.pohlig.de  (C) MPohlig 2004