Java Schnellstart / Java Schnellstart Modul 3 – Wichtige Werkzeuge der Programmierung
0%
In Bearbeitung

Java Schnellstart – Coding Challenge 3 – Zahlenroboter vs. Mensch

Willkommen in der 3. Coding Challenge des Java-Schnellstarts. In den folgenden Aufgaben festigen wir dein Wissen zu den, in diesem Modul gelernten Werkzeugen der Programmierung.

Ziel dieser Challenge ist es, ein Zahlenrate-Spiel in Java zu programmieren.

  1. Der Computer generiert bei Programmstart eine Zufallszahl zwischen 1 und 10.
  2. Du bist der Spieler, der versucht, die Zahl des Computers zu erraten.
  3. Je nachdem, ob du zu hoch, zu niedrig oder richtig geraten hast, soll ein Text in der Konsole ausgegeben werden.

Bisher hast du noch nicht gelernt, wie du Benutzereingaben in der Konsole entgegennehmen und auswerten kannst. Daher werden wir das Zahlenspiel zunächst relativ simpel gestalten. Im Anschluss gebe ich dir eine Zusatzaufgabe, um dein Spiel mit Benutzereingaben (User-Input) noch interaktiver zu machen.

Legen wir los. Die Aufgaben findest du unter dem Editor

Code-Editor:

Aufgabe 1: Zufallszahlen generieren

Das Ziel dieser ersten Aufgabe ist, eine Methode zu schreiben, die eine Zufallszahl zwischen 1 und 10 generiert. Tipp: Falls du Hilfe zur Lösung dieser Aufgabe benötigst, schaue dir die Lektion "Mathe" in diesem Modul erneut an. Hier findest du eine fertige Methode zum Generieren einer Zufallszahl.

  1. Erstelle eine Methode mit dem Namen "zufallsGenerator". Die Methode muss keine Parameter entgegennehmen
  2. Benutze eine geeignete Methode aus der Math-Klasse (siehe Lektion "Math"), um eine Zufallszahl zwischen 1 und 10 zu generieren.
  3. Die generierte Fließkommazahlen, der entsprechenden Methode gibt einen Wert zwischen 0 und 1 zurück (z.B. 0.4389982). Multipliziere sie daher mit * 10. Speichere die Zufallszahl in einer Variable z.B. "zufall" und gib diese Variable an die main-Methode zurück (Tipp: return)
  4. In der Main-Methode: Rufe deine neue Methode "zufallsGenerator" in der Main-Methode auf und speichere die Zahl in einer Variable z.B. "zufallszahl". Tipp: Um deinen Zahlengenerator zu testen, kannst du den Rückgabewert mit println in der Konsole ausgeben.
    1. Der Zufallsgenerator soll eine Ganzzahl (1, 2, 5, 9, usw.) ausgeben. Daher musst du nun die Nachkommastellen entfernen. Benutze hierfür das Typecasting (von double zu int).

[lp_spoiler title="Lösung Aufgabe 1 anzeigen" class="da"]

class Main {
  public static void main(String[] args) {
    // Aufgabe 1
    int zufallszahl = (int) zufallsGenerator(); // Typecasting von "double" zu "int", um Nachkommastellen abzuschneiden
    // Benutze "System.out.println(zufallszahl);" um deinen Zahlengenerator zu testen
    
  }

  public static double zufallsGenerator() {
    double zufall = Math.random() * 10;     // Generiert eine Zahl zwischen 1 und 10 mit Nachkommastellen
    return zufall;    
  }

}

[/lp_spoiler]

Aufgabe 2: Benutzer vs. Roboter - Zahlen vergleichen und auswerten

An dieser Stelle solltest du einen funktionierenden Zahlenzufallsgenerator erstellt haben (s. Aufgabe 1)

Jetzt ist es an der Zeit, das eigentliche Spiel zu erstellen:

Erstelle eine neue Methode mit dem namen "spiel". Die Methode hat keinen Rückgabewert. Außerdem soll die Methode eine Nummer (Ganzzahl) als Parameter entgegennehmen (nenne den Parameter z.B. "nummer"). Hinweis: Diese Nummer ist unsere in Aufgabe 1 erzeugte Zufallszahl. Dazu gleich mehr.

Innerhalb deiner neuen Methode "spiel", soll die Zahl des Spielers definiert werden. Erstelle dazu eine Variable mit dem Namen "raten" und einer zufälligen Zahl zwischen 1 und 10. Da du versuchst, die Zufallszahl des Computers zu erraten, benötigst du eine Variable mit deiner "Ratezahl". Erstelle eine Variable z.B. mit dem Namen "raten" und weise ihr einen Wert zwischen 1 und 10 zu (z.B. 7).

An dieser Stelle haben wir eine "Zufallszahl" des Computers und eine Ratezahl des Spielers. Um zu prüfen, ob der Spieler richtig geraten hat oder nicht, müssen wir diese beiden Zahlen miteinander vergleichen.

Es gibt drei Szenarien, die beim Zahlenraten autreten können:

  1. Du hast zu hoch geraten
  2. Du hast zu niedrig geraten
  3. Du hast richtig geraten!

Decke diese drei Vorgänge mit einer If-Abfrage (If-Verzweigung) und den entsprechenden Bedingungen ab. Tipp: Vergleichsoperatoren benutzen, um zwei Werte miteinander zu vergleichen!

Sobald du die If-Abfrage (if, else if, else) erstellt hast, gehe zurück in die Main-Methode. Rufe nun die Methode "spiel" auf und gib als Parameter die Zufallszahl des Computers mit (bei mir heißt die Variable "zufallszahl")

Starte das Spiel. Du solltest jetzt eine entsprechende Textmeldung in der Konsole bekommen, ob du richtig geraten hast oder nicht. Um erneut zu Raten, musst du das Programm neu starten (grünter "Run"-Button)

[lp_spoiler title="Lösung Aufgabe 2 anzeigen" class="da"]

class Main {
  public static void main(String[] args) {
    int zufallszahl = (int) zufallsGenerator();
    spiel(zufallszahl);
  }

  public static double zufallsGenerator() {
    double zufall = Math.random() * 10;     
    return zufall;    
  }

  public static void spiel(int nummer) {
    int raten = 7;   

    if (raten > nummer) {
       System.out.println("Du hast zu hoch geraten");
    }
    else if (raten < nummer) {
       System.out.println("Du hast zu niedrig geraten");
    }
    else {
       System.out.println("Du hast richtig geraten!");
   }
 }
}

[/lp_spoiler]

Zusatzaufgabe: User-Eingaben entgegennehmen & mehrfaches Raten pro Spiel

An dieser Stelle funktioniert dein simples Ratespiel bereits. Jedoch wäre es hilfreich, wenn wir unsere "Ratezahl" direkt in die Konsole eingeben könnten, anstatt den Wert direkt in der Variable "raten" zu definieren. Außerdem sollten mehrere Ratezüge pro Spiel möglich sein, damit wir eine höhere Chance haben, das Spiel zu gewinnen.

Scanner-Klasse:

Im nächsten Modul (Nr. 4) wirst du mehr zu User-Inputs (Benutzereingaben) erfahren. Um unser Spiel jetzt schon zu verbessern, gebe ich dir in dieser Zusatzaufgabe einen kurzen Einblick in die sogenannte "Scanner"-Klasse.

Mit der Scanner-Klasse, kannst du einen Benutzer auffordern, eine Eingabe z.B. in der Konsole zu machen. Diese Eingabe können wir entgegennehmen und in einer Variable speichern.

Bevor wir Zugriff auf die Scanner-Klasse haben, müssen wir diese in unser Java-Programm importieren.

Dafür schreibst du folgenden Code in die erste Zeile deines Programms:

import java.util.Scanner;  // Import der Scanner Klasse

Jetzt hast du Zugriff auf alle Methoden der Scanner-Klasse. Ein User-Input erstellst du wie folgt:

Scanner s = new Scanner(System.in);  // Scanner mit System.in
System.out.println("Bitte gib eine Zahl zwischen 1-10 ein:"); // Nachricht an den User, dass er eine Eingabe machen soll
String usereingabe = s.nextLine();  // User-Eingabe auslesen und in Variable abspeichern

Schaue dir die Kommentare im obigen Code an, um den "User-Input" besser zu verstehen.

An dieser Stelle kannst du den User-Input der Konsole bequem abspeichern. Es gibt jedoch einen kleinen Haken. Der User-Input wird als "String" gespeichert. Da wir eine Zahl entgegennehmen und diese im Anschluss mit der "Zufallszahl" des Computers vergleichen wollen, müssen wir ein kurzes Typecasting von "String" zu "int" vornehmen. Das geht wie folgt:

raten = Integer.parseInt(usereingabe.trim());

Super! In der Variable "raten" wird jetzt die Ganzzahl gespeichert, die in der Konsole eingegeben wird.

Mehrere Ratezüge pro Spiel

Um eine bessere Chance zu haben, gegen den Computer zu gewinnen (nämlich die richtige Zahl zu erraten), wollen wir mehrere Ratezüge pro Spiel einprogrammieren. Du sollst so lange raten können, bis du gewinnst. Dafür benötigen wir eine while-Schleife (solange bis), die so lange läuft, bis die Zufallszahl gleich der User-Zahl ist. Die while-Schleife soll daher immer ausgeführt werden, wenn die Bedingung "raten != nummer" eintrifft.

Folgende Änderungen musst du in deiner spiel-Methode vornehmen:

  1. Setze die "raten"-Variable auf den Wert 0 (int raten = 0;)
  2. Erstelle eine while-Schleife mit der Bedingung (raten != nummer)
  3. Füge innerhalb der while-Schleife die obigen 4-Zeilen Code, der Scanner-Klassse ein
  4. Füge darunter deine bereits bestehende If-Abfrage (if, else if, else) ein.
  5. Schließe die while-Schleife mit der geschweiften Klammer }

Das war's!

Führe dein Spiel aus. Du kannst deine Zahleneingaben jetzt direkt in der Konsole tätigen. Außerdem kannst du so oft raten, bis du gewonnen hast!

Hier ist die Komplettlösung:

[lp_spoiler title="Komplettlösung anzeigen" class="da"]

import java.util.Scanner;  // Import der Scanner Klasse

class Main {
  public static void main(String[] args) {
    int zufallszahl = (int) zufallsGenerator();
    // System.out.println(zufallszahl);
    spiel(zufallszahl);
  }

  public static double zufallsGenerator() {
    double zufall = Math.random() * 10; 
    // double gerundet = Math.round(zufall);     
    return zufall;    
  }

  public static void spiel(int nummer) {
    int raten = 0;

    while (raten != nummer) {
      Scanner s = new Scanner(System.in);  // Scanner mit System.in
      System.out.println("Bitte gib eine Zahl zwischen 1-10 ein:");
      String usereingabe = s.nextLine();  // Eingabe auslesen
      raten = Integer.parseInt(usereingabe.trim());

      if (raten > nummer) {
        System.out.println("Du hast zu hoch geraten");
      }
      else if (raten < nummer) {
        System.out.println("Du hast zu niedrig geraten");
      }
      else {
        System.out.println("Du hast richtig geraten!");
      }
    }
  }
}

[/lp_spoiler]

Fazit

In dieser 3. Coding-Challenge hast du die Konzepte des dritten Moduls wiederholt. Insbesondere das Wissen zu If-Abfragen sowie Schleifen wurde hier behandelt. Außerdem hast du wichtige Werkzeuge, wie Methoden, Rückgabewerte, Typecasting (double zu int, usw.) wiederholt. Falls einige der Aufgaben zu schwierig waren, kannst du dir die entsprechenden Lektionen erneut anschauen. Es ist jedoch ganz normal, dass die Programme beim Programmieren nicht auf Anhieb funktionieren.

An dieser Stelle hast du bereits viele wichtige Werkzeuge der Java-Programmierung gelernt. Im nächsten Modul schauen wir uns einige Konzepte an, die du noch nicht kennengelernt hast. Weiterhin besprechen wir deinen weiteren Werdegang als Java-Programmierer sowie interessante Projekt-Ideen und Spezialisierungen.