v4.x/Interfaces

Interfaces

Ein Interface gleicht im Prinzip einer Super-Klasse, von der man erben kann. Der Unterschied zur Super-Klasse besteht darin, dass - vereinfacht gesagt - bei einem Interface nur Methoden vererbt werden wohingegen eine Super-Klasse auch Attribute vererben kann. Bei Super-Klassen erbt man mit dem Schlüsselwort extends wohingegen man von einem Interface mit dem Schlüsselwort implements erbt. Sehr oft sind die Methoden eines Interfaces nur Signaturen, das heißt Methoden-Köpfe ohne Rumpf. Der Rumpf wird erst in der Sub-Klasse implementiert. Man spricht dann von überschreiben der Methode. Meist gibt ein Interface eine Funktionalität vor und in der Sub-Klasse kann man frei entscheiden, wie auf diese Funktionalität konkret reagiert werden kann.

In der Edu-Variante der Engine-Alpha gibt es 6 Interfaces:

Interfaces der Edu Variante

• Das Interface TastenReagierbar mit den Methoden
  

public void tasteReagieren( int taste )

public void tasteLosgelassenReagieren( int taste )

public boolean istTasteGedrueckt( int taste )

• Das Interface Ticker mit der Methode

public void tick()

• Das Interface MausklickReagierbar mit den Methoden

public void klickReagieren( double x , double y )

public void klickLosgelassenReagieren( double x , double y )

• Das Interface MausradReagierbar mit der Methode

public void mausRadReagieren( int zaehler )

• Das Interface BildAktualisierungReagierbar mit der Methode

public void bildAktualisierungReagieren( double zeitIntervall )

• Das Interface KollisionsReagierbar mit der Methode

public boolean kollisionReagieren( EduActor ea )

Die Methoden werden bei den entsprechenden Ereignissen automatisch aufgerufen. Die enthaltenen Parameter werden automatisch übergeben und können dann im Rumpf der überschriebenen Methode abgefragt werden.

Die meisten dieser Methoden sind in der Klasse SPIEL bereits vorhanden und du kannst sie in Sub-Klassen von SPIEL überschreiben.
Manchmal möchte man aber ohne SPIEL auskommen oder hat darüber hinausgehende Bedürfnisse. Dann sind diese Interfaces sehr nützlich.

Demo 1: Interface TastenReagierbar

Sobald man dieses Interface implementiert hat, muss man die beiden Methoden public void tasteReagieren ( int taste ) und public void tasteLosgelassenReagieren( int taste ) überschreiben, auch wenn man nur eine davon braucht. Die nicht benötigte Methode überschreibt man in so einem Fall einfach mit leerem Rumpf (nur geschweifte Klammer auf und wieder zu).
Da die Methode public boolean istTasteGedrueckt() immer exakt dasselbe tut, ist im Interface bereits funktionsfertig enthalten.

Interface TastenReagierbar in Aktion

public class Spielfigur
extends FIGUR
implements TastenReagierbar
{
    public Spielfigur()
    {
        super("Flappy-Bird.png");
    }

    @Override
    public void tasteReagieren( int taste )
    {
        if ( taste == TASTE.RAUF )
        {
            super.setzeGeschwindigkeit( 0 , 4 );
        }
        else if ( taste == TASTE.RUNTER )
        {
            super.setzeGeschwindigkeit( 0 , -4 );
        }
        
    }
    
    @Override
    public void tasteLosgelassenReagieren( int taste )
    {
        if ( taste == TASTE.RAUF  ||  taste == TASTE.RUNTER )
        {
            super.setzeGeschwindigkeit( 0 , 0 );
        }
    }
}

Demo 2: Interface Ticker

Sobald man dieses Interface implementiert hat, muss man die Methode public void tick () überschreiben.

Interface Ticker in Aktion

public class Uhr
extends TEXT
implements Ticker
{
    private int sekunden;
    public Uhr()
    {
        super( 0 , 0 , 5 , 0 );
        this.sekunden = 0;
        starteTickerNeu( 1 );
    }

    @Override
    public void tick()
    {
        this.sekunden = this.sekunden + 1;
        super.setzeInhalt( "" + this.sekunden );
        super.setzeMittelpunkt( 0 , 0 );
    }
}

Demo 3: Interface MausKlickReagierbar

... bald ...

Demo 4: Interface MausRadReagierbar

... bald ...

Demo 5: Interface BildAktualisierungReagierbar

... bald ...

Demo 6: Interface KollisionsReagierbar

... bald ...