Turtlegrafik mit Java

HomeAufgabenDruckenJava-Online

Vererbung


Die Vererbung ist ein mächtiges Werkzeug zur Wiederverwendbarkeit von Programmelementen. Die Vererbung basiert auf der Idee, dass Eltern ihren Kindern Eigenschaften und Fähigkeiten (Methoden) mitgeben, die aber auch geändert (überschrieben) werden können. Syntaktisch wird die Vererbung mit dem Schlüsselwort extends beschrieben. Eine mit extends abgeleitete Klasse kann automatisch alle (nicht privaten) Methoden der oberen Klasse (Superklasse) verwenden. Java kennt nur eine einfache Vererbung, d.h. eine Klasse kann nur von einer Superklasse erben.

Modifiers (Zugriffsbezeichner)

Access-Modifier sind Schlüsselwörter public, protected und private, die vor Deklarationen gesetzt werden, um die Sichtbarkeit (Zugriffsrechte) der Instanzvariablen, Methoden oder Klassen festzulegen.

private sichtbar nur in eigener Klasse
public überall sichtbar
protected sichtbar im gleichen Package und in Subklassen

Fehlt der Modifier, so wird standardmäsig der package Zugriff verwendet.

Es gehört zum guten Programmierstil, die Modifiers bewusst einzusetzen, um den Zugriff so weit wie möglich einzuschränken. Insbesondere werden Instanzvariablen in der Regel als private deklariert.

Im ersten Beispiel wird die Klasse Turtle in der abgeleitete Klasse mit einer weiteren Methoden ergänzt.

 

Die Klasse RedTurtle ist von der Klasse Turtle abgeleitet. RedTurtle ist eine Turtle und besitzt damit alle Methoden der Klasse Turtle. Im Konstruktor werden ihre speziellen Eigenschaften angegeben: sie ist rot und zeichnet rot. Zusätzlich hat sie eine Methode stern(), die einen Stern zeichnet.

Die Applikationsklasse Tu21 erzeugt ein Objekt t der Klasse RedTurtle und zeichnet Sterne an verschiedenen Positionen.


 

Die Klassendeklaration von RedTurtle erfolgt üblicherweise in einer eigenen Source-Datei mit dem Namen RedTurtle.java. Da wir im Online-Editor nur eine Datei verwenden können, schreiben wir die Klasse ins gleiche Editorfenster.

// Tu21.java

import ch.aplu.turtle.*;
import java.awt.Color;

public class  RedTurtle extends Turtle
{
  public RedTurtle()
  {
    setColor(Color.red);
    setPenColor(Color.red);
  }

  public void star(double s)
  {
    fillToPoint(getX(),getY());
    for (int i = 0; i < 6; i++)
    {
      forward(s);
      right(140);
      forward(s);
      left(80);
    }
  }
}

public class Tu21
{
  public Tu21()
  {
    RedTurtle t = new RedTurtle();
    t.speed(-1);
    t.star(50);
    t.setPos(-100, -100);
    t.star(30);
    t.setPos(100,120);
    t.star(40);
    t.hideTurtle();
  }

  public static void main(String[] args)
  {
    new Tu21();
  }
}

Erklärungen zum Programmcode:
public RedTurtle()
{
    setColor(Color.red);
    setPenColor(Color.red);
}
 Im Konstruktor der Klasse RedTurtle() werden Eigenschaften der Klasse Turtle geändert. Die RedTurtle ist rot und zeichnet rot
public void stern(double s)
 Deklariert eine Methode stern(), die in der Klasse Turtle nicht vorhanden ist
RedTurtle t = new RedTurtle()
t.stern(50)
 In der Applikationsklasse Tu21 wird eine Instanz der Klasse RedTurtle erzeugt. Diese kann die Methoden der Klasse RedTurtle verwenden (sterne zeichnen)

 

Im nachfolgenden Beispiel modifizieren wir die Methode setColor() aus der Klasse Turtle. Dazu deklarieren wir die Klasse MyTurtle, in der wir setColor() neu deklarieren. Die modifizierte Methode soll neben der Turtlefarbe gleichzeitig auch die Stiftfarbe setzen. Auf diese Art kann eine bestehende Klassenbibliothek beliebig ergänzt und modifiziert werden. Wir nennen dieses Verfahren Überschreiben einer Methode.


// Tu22.java

import ch.aplu.turtle.*;
import java.awt.Color;

public class  MyTurtle extends Turtle
{
  public Turtle setColor(Color c)
  {
    super.setColor(c);
    setPenColor(c);
    return this;
  }
}

public class Tu22
{
  public Tu22()
  {
    MyTurtle t = new MyTurtle();
    t.setColor(Color.red);
    t.forward(100);
  }

  public static void main(String[] args)
  {
    new Tu22();
  }
}
 

Erklärungen zum Programmcode:
public Turtle setColor(Color c)
 Die überschriebene Methode muss denselben Namen, dieselbe Parameterliste und denselben Rückgabetyp besitzen
super.setColor(c)
 Es wird die Methode setColor() der Superklasse Turtle aufgerufen
MyTurtle t = new MyTurtle()
 t ist eine Instanz von MyTurtle. Da MyTurtle von Turtle abgeleitet ist, können alle Methoden von Turtle aufgerufen werden

 

Turtle-Programme können meist dadurch vereinfacht werden, dass man die Applikationsklasse von der Klasse Turtle ableitet. Die Applikationsklasse kann damit alle Methoden der Klasse Turtle ohne den Punktoperator verwenden. Zum Vergleich der beiden Programmiertechniken wird das gleiche Beispiel mit Vererbung (Tu20) und ohne Vererbung (Tu20a) präsentiert.

  


 


mit Vererbung:   ohne Vererbung:
// Tu20.java

import ch.aplu.turtle.*;

public class  Tu20 extends Turtle
{
  public Tu20()
  {
    speed(-1);  
    setPos(-20, -80);
    for (int i = 0; i < 45; i++)
    {
      forward(200);
      right(159.6);
    }
    hideTurtle();
  }

  public static void main(String[] args)
  {
    new Tu20();
  }
} 		  // Tu20a.java

import ch.aplu.turtle.*;

public class  Tu20a
{
  Turtle joe = new Turtle();

  public Tu20a()
  {
    joe.speed(-1);
    joe.setPos(-20, -80);
    for (int i = 0; i < 45; i++)
    {
      joe.forward(200);
      joe.right(159.6);
    }
    joe.hideTurtle();
  }

  public static void main(String[] args)
  {
    new Tu20a();
  }
}