In diesem Abschnitt wollen wir eine Modelleisenbahn simulieren und fahren lassen. Ein Zug besteht aus einer Lokomotive mit angehängten Waggons; das können Personenwagen, Güterwaggons oder andere Spezialwaggons sein. Fürs ersten beschränke wir uns auf die Lokomotive sowie den Personen- und Güterwaggon.

Damit diese zusammenpassen müssen einige Komponenten genormt werden: Alle 3 Typen besitzen vorne und hinten einen Puffer, an dem sich weitere Waggons ankuppeln können. Alle müssen genormte Räder besitzen, damit sie auf derselben Schiene fahren können etc.

Die Gemeinsamkeiten kann man ganz gut in einem abstrakten Fahrzeug "Waggon" zusammenfassen. Ein solcher abstrakter Fahrzeugtyp wird aber niemals auf unseren virtuellen Schienen unterwegs sein. Solche Klassen nennt man abstrakt.

Die abstrakte Klasse Waggon enthält alle gemeinsamen Eigenschaften und Methoden. Sie dient dann später als Vorlage für spezielle Waggons.

In Java wird die Definition einer abstrakten Klasse bei der Definition angegeben:

  public abstract class Waggon {...}

Die Klasse enthält Attribute und Methode, die allen Abkömmlingen zur Verfügung stehen. Außerdem kann festgelegt werden, dass alle Spezialisierungen gewisse Methoden zur Verfügung stellen müssen. Alle konkreten Waggons müssen eine zeichenroutine haben und zur Laufzeit den Grafikkontext bereitstellen. Hier wird nur die Spezifikation angegeben - die Implementierung erfolgt dann in der spezialisierten Unterklasse.

  public abstract void zeichne();
  public abstract void setGraphics(Graphics g);

Gemeinsame Methoden sollten aber hier implementiert werden. So weiß diese Klasse bereits, wie man einen Waggon bewegen kann. Die Methode fahren(int schritte) bewegt den Waggon um schritte nach links (positiv) bzw. nach rechts (negativ). 

  /**
   * Der Waggon wird um eine bestimmte Anzahl Pixel horizontal verschoben.
   * positive Werte verschieben nach links, negative Werte nach rechts.
   *
   * @param schritte  Anzahl Pixel
   */
   public void bewege(int schritte) {..}

Implementiere die Klasse Waggon mit den im folgenden UML-Diagramm angegebenen Methoden. Kommentiere die einzelnen Methoden im Quelltext.

Der Stift wird später zum Zeichnen des Waggons benötigt, die Länge des Waggons wird ebenfalls später festgelegt.

Spezifikation von "Waggon": 

  // ----------- Konstruktor ------------
  Waggon(int x, int y, int len, Color c)
        erstellt einen neuen Waggon der Länge l mit Anfangsposition (x,y)
        in der Zeichenfarbe c   
        Die Anfangsposition ist der Mittelpunkt des linken Puffers

  // ----------- Attribute ------------ 
  int   laenge 
        Länge des Waggons (von Puffer zu Puffer)

  Stift pinsel
        Stift zum Zeichnen des Waggons

  // ----------- Methoden ------------ 
  void  zeichne()
        abstrakte Methode (wird in Unterklassen definiert)

  void  setGraphics(Graphics g)
        der Grafikkontext für den Pinsel wird gesetzt

  int   getLaenge()
        liefert die aktuelle Länge

  int   getPositionX()
        liefert die aktuelle x-Position des Waggons

  int   getPositionY
        liefert die aktuelle y-Position des Waggons

  void  fahren(int strecke)
        Der Waggon wird um eine bestimmte Strecke (Anzahl in Pixel)
        verschoben. Positive Werte für strecke verschieben nach links,
        negative nach rechts.