Abstrakte Klassen

Auf dieser Seite lernst du das Konzept der → Abstrakten Klassen kennen.

Aufgabe:

• Drei Hamster liefern sich ein Wettrennen:
  • der erste Hamster geht bei jedem Zug eine zufällige Anzahl von Schritten vorwärts.
  • Der zweite Hamster will gleich bis zum Ende durchlaufen und so den Sieg für sich haben. Leider bleibt er einen Schritt zu früh stehen.
  • Der dritte Hamster haut die beiden anderen übers Ohr: Er würfelt mit zwei Würfeln und geht die entsprechende Anzahl von Schritten vorwärts.
  




• Speichere das Programm unter abstrakteklasse_hamsterrennen.

Tipps:

• Erweitere das → Beispiel um eine abstrakte Methode freuen()
• Erstelle drei Klassen als Erben der abstrakten Klasse LaufHamster:
• RennHamster: sie realisiert den "ehrlichen" Hamster, der nur einmal würfelt.

  class RennHamster extends LaufHamster 
  {
      RennHamster(int reihe, int spalte, int blickrichtung, int koerner)
      {
          super(reihe, spalte, Hamster.OST, 0);
      } 
      . . . .
  }

• DummerHamster: sie beschreibt den Hamster, der vergisst den letzten Schritt zu laufen.
• GedopterHamster: sie enthält den Hamster, der zweimal würfelt
• Alle drei Klassen enthalten die Methoden laufe() und freuen().
  Die Methode laufe() ist natürlich für die drei Hamster unterschiedlich.
  Gemeinsam ist ihnen, dass sie alle dynamisch gebunden auf die abstrakte Methode laufe() des LaufHamsters zugreifen.
  Die Methode freuen() ist für alle drei gleich.
• Im Hauptprogramm werden die Hamster initialisiert:

      RennHamster paul = new RennHamster(0, 0, Hamster.OST, 0);
      DummerHamster willi = new DummerHamster(1, 0, Hamster.OST, 0);
      GedopterHamster karl = new GedopterHamster(2, 0, Hamster.OST, 0);
  

• Der Sieger darf sich freuen.

Aufgabe:

• Zwei Hamster spielen gegeneinander.
  Gewonnen hat der Hamster der zuerst das letzte Korn übereinander legt.
  • Hamster willi spielt nach dem Zufallsprinzip.
  • Hamster paul beobachtet die Züge seines Gegners und legt die Körner entsprechend.




• Speichere das Programm unter 4_koerner.

Tipps:

• Erstelle eine → abstrakte Klasse VierGewinntHamster als Erbe der Klasse AllesKoennerHamster:

  abstract class VierGewinntHamster extends AllesKoennerHamster 
  {
      VierGewinntHamster(int reihe, int spalte, int blickrichtung, int koerner)
      {
          super(reihe, spalte, blickrichtung, koerner);
      }
  

  Mit den Methoden:

      
      abstract void lege();
      abstract int anzahlKoernerReihe(int anzahlKoerner); 
  }
  

  Diesen Methoden werden nach den Pronzipien der → Polymorphie und des → Dynamischen Bindens in den Klasse ZufallsHamster und StrategieHamster verwendet.
• Verwende die Klasse → Zufall.
• In den Klassen ZufallsHamster und StrategieHamster werden die Methoden geheZuKachel() und setzeBlickrichtung() des AllesKoennerHamsters verwendet.
• Der ZufallsHamster legt nach dem Zufallsprinzip jeweils ein Korn in der untersten Reihe ab.

      void lege()
      {
          int position = 0;
      	Zufall zahl = new Zufall();
          this.geheZuKachel(Territorium.getAnzahlReihen() - 1, . . .);
          
          // der Hamster dreht sich in Richtung NORD
          this.setzeBlickRichtung(Hamster.NORD);
          
          // der Hamster geht solange vorwärts bis er auf eine leere Kachel trifft
          int reihe = anzahlKoernerReihe(position);
          this.gib();
          
          // der Hamster hat die Reihe 0 erreicht und gewonnen
          if (this.getReihe() == 0)
          {
              . . .
          }
      }
  

• Schreibe die → int-Funktion anzahlKoernerReihe().
  Sie gibt die Position der ersten freien Kachel in der Reihe zurück.

      int anzahlKoernerReihe(int position)
      {
          . . .
      }
   

• Der StrategieHamster geht planvoll vor:
  • er geht alle Spalten ab und stellt fest, wie viele Körner schon übereinander liegen.
  • er legt nach Möglichkeit dort ein Korn ab wo noch keins liegt ...
  • ... oder dort, wo erst ein Korn liegt.
  • findet er eine Spalte, wo bereits drei Körner übereinander liegen, nutzt er seine Chance zum Sieg.
  • Die Anzahl der übereinander liegenden Körner werden in einem → Array gespeichert.

    void lege()
    {
        int reihe [] = new int [5];

        // kornGegeben true -> Spalten müssen nicht erneut abgelaufen werden
        boolean kornGegeben = false;
    	
        /* 
    	   alle Spalten abgehen und die Anzahl der Körner feststellen und 
    	   mit Hilfe der Funktion anzahlKoernerReihe in das Array reihe schreiben
         */

        for (int zaehler = 0; zaehler < Territorium.getAnzahlSpalten(); zaehler ++)
        {
            this.geheZuKachel(. . .);
            . . . 
            
            // 3 Körner in der Spalte -> gewonnen -> Methode lege sofort mit return verlassen
            if (reihe[zaehler] == 3) 
            {
                . . .
            }  
            
            /*
               keine Körner in der Spalte -> sofort legen 
               kornGegeben auf true setzen -> die Spalten müssen nicht erneut abgelaufen werden
             */

            if (reihe[zaehler] == 0) 
            {
                . . .
            }    
             
        }
        
        /*
           kornGegeben false -> erneutes Ablaufen der Spalten -> gibt es eine Spalte mit 1 Korn?
           kornGegeben auf true setzen-> die Spalten müssen nicht erneut abgelaufen werden
         */
                    
        if (!kornGegeben)
        {
            for (int zaehler = 0; zaehler < Territorium.getAnzahlSpalten(); zaehler ++)
            {
                this.geheZuKachel(. . .);
                this.setzeBlickRichtung(Hamster.NORD);
            
             
                if (reihe[zaehler] == 1) 
                {
                    . . .
                }
            }
        }
        
        /*
           kornGegeben false ->  erneutes Ablaufen der Spalten -> liegen überall 2 Körner?
           kornGegeben auf true setzen-> die Spalten müssen nicht erneut abgelaufen werden
         */
        if (!kornGegeben)
        {
            for (int zaehler = 0; zaehler < Territorium.getAnzahlSpalten(); zaehler ++)
            {
                this.geheZuKachel(. . .);
                         
                if (reihe[zaehler] == 2) 
                {
                    . . .
                }
            }
        }
    }

• anzahlKoernerReihe() gibt die Anzahl der Körner in einer Spalte zurück.