Ein Spielautomat besteht aus drei Spielwalzen. Bei zwei oder drei gleichen Farben gewinnt man Geld.

1. Implementiere die Klasse SPIELAUTOMAT. Füge geeignete Attribute, einen Konstruktor SPIELAUTOMAT() und eine Methode zeichne() ein.
2. Die Methode setzeFarbmuster(int z1Neu, int z2Neu, int z3Neu) soll die Spielwalzen entsprechend umfärben. Dazu benötigen wir in VOLLKREIS eine Setter-Methode für das Attribut Farbe und in SPIELWALZE eine Methode, die den umfärben Befehl vom SPIELAUTOMATEN an die VOLLKREIS Setter-Methode weitergibt.
3. Erstelle eine Methode schreibeWerte(), die die drei Farben beim Farbwechsel über System.out.println() ausgibt.
4. Informiere dich in der Java-Klassendokumentation über die Klasse java.util.Random.
5. Füge ein Objekt dieser Klasse in die Klasse SPIELAUTOMAT ein. Das Objekt wird als Zufallsgenerator verwendet und muss im Konstruktor initialisiert werden.
6. In einer Methode spiele() sollen mithilfe des random-Objekts drei neue Zufallszahlen im Zahlenbereich 0 bis 8 bestimmt und der Methode setzeFarbmuster() als Parameter übergeben werden.
7. Welches Zugriffsrecht sollte die Methode setzeFarbmuster(int z1Neu, int z2Neu, int z3Neu) haben? Begründe!

Importieren von Klassen in Java

• Die Klasse Random muss der Klasse SPIELAUTOMAT durch die Anweisung import java.util.Random; bekannt gemacht werden.
• Dies geschieht vor der Klassendeklaration (also vor public class SPIELAUTOMAT).
• Mit der Anweisung import Paketname.Klassenname; kann man eine bereits vorhandene Java-Klasse verwenden.
• Mit import Paketname.*; verfügt man über alle Klassen des Pakets.
• Bsp.: import java.util.Random;

Die Methode spiele() aus der vorhergehenden Aufgabe simuliert einen Spielvorgang und setzt das Farbmuster des Spielautomaten damit neu. Es soll jetzt zwei Gewinnregeln geben.

Gewinnregel 1: Wenn drei gleiche Farben am Spielautomat erscheinen, soll der Spielautomat einen Gewinn von 10 Euro ausgeben. Andernfalls soll ein Gewinn von 0 Euro ausgegeben werden.

Gewinnregel 2: Wenn nur zwei gleiche Farben erscheinen, werden 2 Euro ausgeschüttet.

1. Setze zunächst nur die Gewinnregel 1 um. Schreibe dazu eine Methode ermittleGewinn(), die den Gewinn als Rückgabewert liefert.
2. Teste deine Methode auf Korrektheit.
3. Setze nun auch die Gewinnregel 2 um. Erweitere die Methode ermittleGewinn() dabei.
4. Teste die Methode erneut auf Korrektheit.
5. Erweitere die Methode schreibeWerte() so, dass sie den Gewinn ausgibt.

In einem realen Spielautomat kann nur gespielt werden, wenn noch Guthaben vorhanden ist. Bei jedem Spiel wird 1 € vom Guthaben abgezogen, der Spielgewinn aber gutgeschrieben.

1. Füge in die Klasse SPIELAUTOMAT ein Attribut guthaben ein (Anfangswert 0).
2. Schreibe eine Methode guthabenEinzahlen(int betrag) {…} die den Einzahlungsvorgang simuliert
3. Modifiziere die Methode spiele() so, dass sie
   1. vor dem Spiel das aktuelle Guthaben um 1 verringert
   2. nach dem Spiel den Gewinn ermittelt und das Guthaben anpasst.
4. Der Spielautomat soll nun vor dem Spielvorgang prüfen, ob noch genügend Guthaben vorhanden ist und den Spielvorgang nur dann durchführen, wenn mindestens noch 1 EUR vorhanden ist. Andernfalls soll er die Meldung ausgeben: „Alles Verzockt! Wirf mehr Geld ein!“
5. Modifiziere die Methode schreibeWerte() in geeigneter Form um das Ausgabeformat zu erhalten.

Die Ausgabe könnte dabei so aussehen:
Es wurden 3 EUR eingezahlt.
Ausgabe: 664 Gewinn: 2 Guthaben: 4
Ausgabe: 230 Gewinn: 0 Guthaben: 3
Ausgabe: 477 Gewinn: 2 Guthaben: 4
Ausgabe: 537 Gewinn: 0 Guthaben: 3
Ausgabe: 645 Gewinn: 0 Guthaben: 2
Ausgabe: 426 Gewinn: 0 Guthaben: 1
Ausgabe: 531 Gewinn: 0 Guthaben: 0
Alles Verzockt! Kein Spiel möglich! Wirf mehr Geld ein!

Der Spielautomat soll eine Methode public void gewinneSicher(){…} erhalten, die solange die Methode spiele() aufruft, bis ein Gewinn (egal wie viel) vorliegt.

1. Implementiere die Methode gewinneSicher() wie oben beschrieben.
2. Die Methode gewinneSicher() soll nun solange weiterspielen, bis genau 10 EUR gewonnen wurden. Modifiziere die Methode entsprechend.
3. Prüfe was passiert, wenn man diese Methode aufruft ohne dass ein Guthaben vorhanden ist. Modifiziere die Methode gewinneSicher() so, dass sie nur dann den Spielvorgang auslöst, wenn zusätzlich genug Guthaben vorhanden ist. Der Spielvorgang wird also maximal nur solange wiederholt, solange Guthaben vorhanden ist.
4. Zähle die Anzahl der Spielvorgänge, die notwendig sind, bis 10 EUR gewonnen wurden. Führe dazu eine Variable int anzahl = 0; ein, die entsprechend verändert wird. Gib die Anzahl anschließend mit System.out.println() aus.

Die Ausgabe könnte dabei so aussehen:
Es wurden 100 EUR eingezahlt.
1. Ausgabe: 738 Gewinn: 0 Guthaben: 99
2. Ausgabe: 267 Gewinn: 0 Guthaben: 98
3. Ausgabe: 666 Gewinn: 10 Guthaben: 107
Es waren 3 Spielvorgänge notwendig!

Der Spielautomat soll eine Methode public void spieleSelbst(){…} erhalten, die automatisch weiterspielt, solange ein positives Guthaben vorhanden ist.

1. Implementiere die Methode spieleSelbst() wie oben beschrieben.

Lohnt sich der Spielautomat, aus wirtschaftlicher Sicht, für den Betreiber? Der Betreiber würde gerne wissen, wie viel ein Spielautomat im Durchschnitt auszahlt.

Die Höhe des Gewinns im Automaten speichern
Dazu muss natürlich erst einmal die Höhe des Gewinns bei jedem Spielvorgang gespeichert werden. Da als Gewinn nur die Werte 0, 2 oder 10 EUR in Frage kommen, wird man jedem Spielautomaten ein Integer-Array hinzufügen. Betrachtet man die maximalen Werte der elementaren Datentypen für Ganzzahlen in Java stellt man fest, dass sogar ein byte Array dafür ausreicht.

Der Gewinn von Spiel 1 kommt in den Array-Speicherplatz mit Index 0; der von Spiel 2 in Index 1 u.s.w.

Das Array muss zunächst in der Attributliste deklariert und im Konstruktor initialisiert werden (z.B. mit 100 000 Speicherplätzen oder auch 2.147.483.647). In der Methode spiele() muss dann der aktuelle Gewinn im Array gespeichert werden. Die bereits implementierte Methode ermittleGewinn() liefert den aktuellen Gewinn. Auf welchem Speicherplatz soll der aktuelle Gewinn gespeichert werden? Der Spielautomat benötigt eine Variable (nennen wir sie mal „spielAnzahl“), die sich den aktuellen Speicherplatz im Array merkt. Diese Variable muss erhöht werden, nachdem man den Gewinn im Array gespeichert hat, sonst würde man den Speicherplatz 0 bei erneutem Aufruf der spiele-Methode immer wieder überschreiben.

1. Füge jedem Spielautomaten ein integer oder byte-Array als Attribut hinzu und speichere den aktuellen Gewinn im Array. Modifiziere dazu die Methode spiele() wie oben beschrieben und verwende auch die ermittleGewinn-Methode.
2. Teste, ob die spiele-Methode den aktuellen Gewinn im Array speichert. Rufe dazu die spiele Methode z.B. 100 mal auf (Testmethode schreiben) und schau Dir das Array danach im Objektinspektor an.

Die Summe der Gewinne berechnen
Um den durchschnittlichen Gewinn des Automaten zu berechnen ist es notwendig, die Summe der Gewinne aller bisher gemachten Spiele zu berechnen. Damit dies gelingt, muss ein Spielautomat zu jedem Zeitpunkt wissen, wie viele Spiele seit seiner Erzeugung gemacht wurden (dies ist in der Variablen spielAnzahl gespeichert) und welche Gewinne vorliegen (dies ist im Array gespeichert).

Um die Summe der Gewinne zu berechnen, geht man mittels einer for-Schleife durch das Array und addiert einfach immer den gespeicherten Gewinn auf eine vorher erzeugte, temporäre Variable. Man läuft bei 0 los und geht bis zu anzahlSpiele. Um den durchschnittlichen Gewinn zu berechnen, teilt man die Summe nun durch die Anzahl der Spiele.

1. Schreibe eine Methode berechneMittel(), die den durchschnittlichen Gewinn des Automaten zum aktuellen Zeitpunkt berechnet. Benutze die Summen-Methode.
2. Schreibe eine Methode zaehleHauptgewinne() die, die Anzahl der Hauptgewinne zurückgibt. Verwende eine for-Schleife um durch das Array zu laufen und if/else um zu entscheiden ob ein Hauptgewinn vorliegt. Zähle die Hauptgewinne in einer neuen Variablen und gib sie mit return zurück.
3. Schreibe (analog zu 3.) die Methoden zaehleKleinGewinne() und zaehleVerluste();

Bisher hatten wir den GewinnSpeicher (das ist das Array, das die Gewinne speichert) als ein byte-Array implementiert. Die Länge eines Arrays muss man beim Initialisieren des Arrays mit angeben. Dabei kann man sehr große Werte angeben. Aber Fakt ist: Jedes Array ist irgendwann voll. Und dann? Dann schmeisst Dir Java diese Fehlermeldung um die Ohren:

Exception in thread „main“ java.lang.ArrayIndexOutOfBoundsException: …

Dein Programm kann dann nicht weiter benutzt werden und Du musst einen neuen Spielautomaten erstellen (nur weil das Array voll ist). Das Problem am Array ist, dass die Länge fix ist. Deshalb gibt es eine Alternative zum Array. Das ist die ArrayList. Die ArrayList ist eine Datenstruktur, die dynamisch wächst. Wenn man ein Element dazulegt (mit der Methode add()) wächst die Länge der ArrayList um ein Element an.

//Datenstruktur ArrayList importieren
import java.util.ArrayList;
 
//ArrayList deklarieren (Datentyp und Name festlegen)
ArrayList<Byte> GewinnSpeicher;    
 
//ArrayList initialisieren
GewinnSpeicher = new ArrayList<Byte>();
 
//Ein Element (2) in die ArrayList legen
GewinnSpeicher.add(2);
 
//Das Element mit Index 5 aus der ArrayList holen
GewinnSpeicher.get(5);
 
//Die Länge der ArrayList ermitteln
GewinnSpeicher.size();

1. Schaue Dir die Methoden der ArrayList in der Java-Api an: https://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html
2. Arbeite die Präsentation durch: https://www.informatikzentrale.de/java-arraylist.html
3. Ersetze den Array-GewinnSpeicher im Spielautomaten durch einen ArrayList-GewinnSpeicher.
4. Beobachte die ArrayList dabei im Objekt-Inspektor und beobachte insbesondere, welche Länge die ArrayList hat, wenn die 0,1,10,11,12,20,21 Elemente hat.

Statte den Spielautomaten mit einer Graphischen Benutzeroberfläche aus.

1. Graphische Benutzeroberflächen
2. Action Listener