v4.x/Methoden ueberschreiben

Dies ist ein Tutorial für die Edu-Variante der Engine Alpha 4.x. Eine Übersicht aller Edu-Tutorials siehst du hier.

Inhalt

In diesem Tutorial:

• Lernst du das Verhalten von geerbten Methoden zu verändern:
  • Du reagierst auf Tastatur-Ereignisse
  • Du startest einen Ticker, der fortwährend Aufgaben automatisch erledigt
  • Du verstehst wie Bewegungen dargestellt werden und reagierst dadurch exakt auf Kollisionen

Überschreiben von Methoden

Bisher hast du entweder vorhandene Methoden aufgerufen oder du hast in deinen Klassen selbst neue Methoden erstellt. Manchmal ist es nützlich, geerbte Methoden abzuändern. Manchmal möchtest du dem bisherigen Verhalten einfach nur etwas hinzufügen. Manchmal erbst du einen Mechanismus, z.B. Reaktion auf Maus oder Tastatur und nun willst du selbst festlegen, was z.B. bei deinem Mausklick passieren soll. In beiden Fällen überschreibt man die geerbte Methode, das heißt man erstellt eine Methode, die man genau in diesem Wortlaut und mit dieser Parameterliste schon geerbt hat.

public class MeineKlasse
extends Oberklasse
{
   ...
   @Override
   public nameDerGeerbtenMethode( ... Paramterliste ... )
   {
      // jetzt passiert was ich will
   }
}

Reaktion auf Tastatur-Ereignisse

Klasse SPIEL

In der Edu-Engine gibt es eine Klasse SPIEL die dir einige Mechanismen anbietet, wenn du von ihr erbst. Einer dieser Mechanismen ist die Fähigkeit, automatisch auf Tastatur-Eingaben reagieren zu können.

Vorübung

Erstelle in deiner Entwicklungsumgebung interaktiv ein Objekt der Klasse Spiel. Nutze zunächst den Konstruktor ohne Parameter. Drücke nun auf deiner Computertastatur eine beliebige Taste. Was beobachtest du?

Konsolenausgabe

Jedes mal wenn du eine Taste drückst erscheint auf der Konsole die Ausgabe "Taste ... wurde gedrückt". Die Klasse Spiel verfügt also über einen Mechanismus um automatisch auf Tastatur-Ereignisse zu reagieren. Wie Geht das?

Die Klasse SPIEL verfügt über die Methode public void tasteReagieren(int tastenCode), die jedesmal automatisch aufgerufen wird, wenn ein Tastatur-Ereignis eintritt. Der Methode wird außerdem automatisch eine Zahl (der Tasten-Code) übergeben. Jede Taste hat eine andere Nummer und so kannst du anhand der Nummer wissen, welche Taste es war.

public class MeinSpiel
extends SPIEL
{
   @Override
   public void tasteReagieren(int tastenCode)
   {
      if ( tastenCode == 38 )
      {
         // Das geschieht bei Taste "Pfeil rauf"
      }
      else if ( tastenCode == ... )
      {
         ...
      }
   }
}

Du musst eine Unterklasse von SPIEL erstellen und darin die geerbte Methode public void tasteReagieren(int tastenCode) überschreiben. Standardmäßig gibt sie auf der Konsole den bekannten Text aus. Du schreibst nun in ihrem Rumpf eine Fallunterscheidung anhand der übergebenen Nummer. So kannst du auf jede beliebige Taste individuell reagieren.

Der Tasten-Code

Klassenkarte TASTE

Nun ist es mühsam, sich für jede benötigte Taste die Nummer zu merken. Deshalb gibt es die Klasse TASTE, die via Punktnotation sprechende Konstanten für jede Taste zur Verfügung stellt: TASTE.A ... TASTE.Z , TASTE._0 ... TASTE._9 , TASTE.RAUF, TASTE.RECHTS, TASTE.RUNTER, TASTE.LINKS, TASTE.LEER, TASTE.ENTER, ...

Du kannst weitere Konstanten in der Klasendokumentation nachlesen.

public class MeinSpiel
extends SPIEL
{
   @Override
   public void tasteReagieren(int tastenCode)
   {
      if ( tastenCode == TASTE.A )
      {
         // Das geschieht bei Taste A
      }
      else if ( tastenCode == TASTE.B)
      {
         ...
      }
   }
}

Der Code ist nun leichter lesbar!

In den einzelnen Fällen kannst du geerbte Methoden, eigene Methoden oder Methoden von Referenzen aufrufen.

Der Folgende Code in der Klasse Haus steuert den Tag- und Nacht-Modus über die Tastatur:

public class Haus
extends SPIEL
{
   ...
   @Override
   public void tasteReagieren(int tastenCode)
   {
      if ( tastenCode == TASTE.N )
      {
         this.nacht();
      }
      else if ( tstenCode == TASTE.N )
      {
         this.tag();
      }
   }

Reaktion auf Kollisionen

Um auf andere Objekte zu reagieren stellt die Klasse EduActor für all ihre Unterklassen die Methode public boolean beruehrt(EduActor anderer) zur Verfügung. Diese Methode müsste während eines Spiels allerdings permanent aufgerufen werden, da sich die Spielfiguren ja andauernd bewegen. Im Idealfall müsste man dies bei jeder auch nur kleinsten Bewegung irgendeiner Spielfigur prüfen. Wie geht das?

Dazu musst du erst verstehen, wie die Grafiken und Animationen auf deinem Bildschirm entstehen. Der Eindruck einer Bewegung am 2D-Bildschirm entsteht durch eine sehr schnelle Folge von Einzelbildern zwischen denen sich nur kleinste Änderungen ergeben haben. In der Regel werden dir heute 30-60 solcher Bilder pro Sekunde untergejubelt, wenn du eine flüssige Bewegung wahrnehmen sollst.

Die Klasse SPEIL verfügt neben der Methode zum automatischen Reagieren auf Tastatur-Ereignisse über eine Methode bildAktualisierungsReagieren(double zeit) die jedesmal automatisch aufgerufen wird sobald ein neues Bild gezeichnet wird. Automatisch wird auch die Zeit in Sekunden mitgeliefert, die seit der letzten Bildaktualisierung vergangen ist. (Diese Zeit liegt etwa im Bereich 1/60 Sekunde, da die Engine etwa 60 Bilder pro Sekunde erzeugt. Für die folgende Anwendung werten wir diesen Parameter aber nicht aus.) Durch überschreiben dieser Methode kannst du am sinnvollsten auf Kollisionen reagieren.

Anregungen zu Experimentieren

• Steuere die Ampelphasen des Ampel-Projekts mit der Tastatur.
• Steuere die Schläger des Pong-Projekts über die Tastatur. Informiere dich über die auch noch vorhandene Methode tasteLosgelassenReagieren(...). Mit ihr in Zusammenarbeit mit tasteReagieren(...) kannst du erreichen, dass bei drücken einer Taste die Geschwindigkeit des Schlägers so gesetzt wird dass dieser sich ab jetzt bewegt. Beim loslassen der Taste wird die Geschwindigkeit des Schlägers auf Null gesetzt und er bleibt stehen.

Das Tutorial ist beendet. Das nächste ist _yyy_ . Wenn du Feedback für uns hast, melde dich gerne.