Java Übung & Lösung: Erstelle ein Mathematik- und Rechenprogramm
In dieser Java Übung möchte ich mit dir ein Programm erstellen, welches ein Mathematik-Test oder eine Mathe-Olympiade simuliert.
Du kennst das vielleicht noch aus der Schule.
Matheolympiade- Da wurden aus allen vier Grundrechenarten, Aufgaben formuliert.
Die Schüler mussten diese Aufgaben lösen.
Die Lehrer kontrollierten die Lösungen.
Und der Schüler, welcher die wenigsten Fehler hatte – gewann die Olympiade.
Und genau so eine Matheolympiade werden wir jetzt simulieren.
Ziel soll es sein, dass du beim Programmstart zwei Werte eingibst.
- Wert 1: Ist die Anzahl der Aufgaben, welche dir gestellt werden.
- Wert 2: Ist der Wertebereich /Größenbereich, in welchem sich die Zahlen zu den Aufgaben befinden.
Und dann werden, anhand deiner Angabe zur Anzahl, Matheaufgaben gestellt.
Diese Aufgaben sind zufällige Aufgaben mit zufälligen Operationen.
Es wird somit ausgewürfelt, welche Rechenart (+, – , / , * ) gestellt wird.
Auch die Zahlen in den Aufgaben sind zufällig vom Programm ermittelt worden.
Um es einfach zu halten, sind alle Zahlen ganzzahlig – also ohne Komma.
Der Nutzer rechnet die ihm gestellte Aufgabe aus und gibt das Ergebnis in der Konsole ein.
Das Programm prüft die Lösung und zählt die Fehler.
Wenn alle Aufgaben durchgerechnet worden, erfolgt eine Konsolenausgabe.
In dieser steht dann:
„Die Anzahl der Fehler ist…..“
Hier ein kurzes Video dazu:
Mit dem Laden des Videos akzeptieren Sie die Datenschutzerklärung von Vimeo.
Mehr erfahren
Aufgabenstellung:
Erstelle die Klasse „MatheOlympiade“
Und lege dann alle 8 Klassenmethoden an:
- die main-Methode
- starteProgramm()-Methode
- generiereAufgaben()-Methode
- addiere()-Methode
- subtrahiere()-Methode
- multipliziere()-Methode
- dividiere()-Methode
- gibInfo()-Methode
Die main-Methode ruft die statische, parameterlose „starteProgramm-Methode“ auf.
Die Methode „starteProgramm()“ fordert dich dann auf zwei Eingaben zu vollziehen.
Und zwar den Wertebereich („wertebereich“) und die Anzahl der Aufgaben („anzahlAufgaben“).
Wenn du beide Eingaben gemacht hast, soll die „starteProgramm()-Methode“ die „generiereAufgaben()-Methode“ aufrufen.
Beim Aufruf wird der Wertebereich übergeben.
Die „generiereAufgaben“-Methode ruft in zufälliger Reihenfolge die Rechenmethoden auf.
Alle Rechenmethoden sollen:
- Zufallszahlen generieren,
- Daraus Konsolenausgaben mit Rechenaufgaben erzeugen,
- Deine Eingabe speichern und überprüfen.
- Feedback, wie richtig oder falsch, geben.
- Falsche Ergebnisse zählen.
Wenn alle Aufgaben erledigt worden, ruft die generiereAufgaben-Methode – die gibInfo()-Methode auf.
Und die gibInfo()-Methode erzeugt eine Bildschirmausgabe mit der Anzahl der Fehler.
So alles klar?
Na dann…
Ich wünsche Dir viel Erfolg beim Lösen dieser Java Übung.
Inhalt
- 1 Beginne bei den Variablen
- 2 So kannst du Zufallszahlen für deine Java Methoden anlegen.
- 3 Kommen wir zu den Methoden.
- 3.1 So legst du die Additions-Methode an.
- 3.2 Die Multiplizieren-Methode kannst du anlog zur Addieren-Methode schreiben.
- 3.3 Bei der Subtraktionsmethode ist es etwas anders.
- 3.4 Die letzte Rechenmethode ist die Division.
- 3.5 Das Herzstück des Programmes ist die generieren()-Methode.
- 3.6 Die letzte Methode soll nur Informationen geben.
- 4 Hier ist die komplette Lösung zu dieser Java Übung
Beginne bei den Variablen
Das Grundgerüst der Klasse sieht so aus:
public class MatheOlympiade {
static void starteProgramm(){
}
public static void main(String[] args) {
starteProgramm(); //Aufruf der start-Methode
}
}
Jetzt meine Frage:
Welche Variablen braucht das Programm?
Klar, die Variablen um die Zufallszahlen zu speichern.
Nein diese meine ich nicht.
Diese Variablen sind lokal.
Sie werden somit direkt in den Methoden angelegt.
Und dies vollziehen wir auch erst dann, wenn wir die Methoden anlegen.
Was du aber zu Beginn brauchst, sind die Variablen um:
- Den Wertebereich festzulegen
- Die Fehleranzahl zu speichern
- Und die Anzahl der Aufgaben zu speichern.
Wie sollten diese Variablen sein?
Oder anders gesagt: Welche Anforderungen stellt das Programm an diese Variablen?
Die Fehleranzahl soll von den Rechenmethoden genutzt werden.
Die einzelnen Methoden sollen den Wert der Variable um Eins erhöhen, sobald dein eingegebenes Ergebnis falsch ist.
Das bedeutet, dass alle vier Methoden auf ein- und dieselbe Variable zugreifen sollen.
Und das bedeutet wiederum, dass die Variable „fehlerAnzahl“ eine Klassenvariable sein sollte.
static int fehlerAnzahl;
Die Variable „werteBereich“ soll ebenfalls von allen Methoden genutzt werden.
In der Aufgabenstellung beschrieb ich aber, dass dieser abgefragt, gespeichert und übergeben wird.
Somit wird dieser als lokale Variable, innerhalb der Start-Methode, angelegt.
Und zwar so:
import java.util.Scanner;//Importanweisung für die Scanner-Klasse
public class MatheOlympiade {
static int fehlerAnzahl;//Klassenvariable -somit haben alle Methoden Zugriff
static void starteProgramm(){
Scanner scanner = new Scanner (System.in);//neues Scanner-Objekt
System.out.println("Gib den Wertebereich an!");//Konsolenaufforderung
int werteBereich=scanner.nextInt();//Konsoleneingabe wird gespeichert
//Wertebereich an generiereAufgaben-Methode übergeben
}
public static void main(String[] args) {
starteProgramm();
}
}
Was passiert hier?
Da du eine Konsoleneingabe speichern möchtest, benötigst du ein Objekt aus der Scannerklasse.
In diesem Beispielcode habe ich eine Referenzvariable, namens „scanner“ angelegt.
Diese Variable verweist auf das Scanner-Objekt.
Scanner scanner = new Scanner (System.in);
Dann erfolgt die Aufforderung zur Eingabe des Wertebereichs.
System.out.println("Gib den Wertebereich an!");
Und die Zahl, welche du dann in die Konsole eingibst, wird in der Variablen „werteBereich“ gespeichert.
int werteBereich=scanner.nextInt();
So einfach.
Eine Variable fehlt noch:
Die Anzahl der Aufgaben.
Der Wert dieser Variable soll ebenfalls in der Start-Methode vergeben werden.
Die „generieren-Methode“ soll aber den Wert der Variablen lesen.
Und dann dementspechend viele Aufrufe der Rechenmethoden erzeugen.
Im Klartext:
Die Variable sollte ebenfalls statisch, also eine Klassenvariable sein.
Das bedeutet:
Du legst diese auf Klassenebene an.
Den Wert bekommt sie aber erst in der Methode zugewiesen.
import java.util.Scanner;//Importanweisung für den Scanner
public class MatheOlympiade {
static int fehlerAnzahl;//statisch-Wert kann von den Rechenmethoden verändert werden
static int aufgabenAnzahl;//statisch-kann von Methode "generiereAufgaben" genutzt werden
static void starteProgramm(){
Scanner scanner = new Scanner (System.in);//Neues Scannerobjekt
System.out.println("Wie viele Aufgaben willst du lösen?");
aufgabenAnzahl=scanner.nextInt();//speichert die Aufgabenanzahl
System.out.println("Gib den Wertebereich an!");
int werteBereich=scanner.nextInt();//lokale Variable speichert den Wertebereich
//hier kommt der Code zu generiereAufgaben(werteBereich);
}
public static void main(String[] args) {
starteProgramm();
}
}
So die erste Methode steht.
Später werden wir dann noch die generieren-Methode aufrufen und den Wertebereich übergeben.
Machen wir mit den Rechenmethoden weiter.
Diese sind eigentlich nicht kompliziert.
Sie unterscheiden sich aber an gewissen Stellen.
Was aber alle Rechenmethoden gemeinsam haben, sind die Zufallszahlen.
Und wie du diese erstellst, möchte ich dir jetzt zeigen.
So kannst du Zufallszahlen für deine Java Methoden anlegen.
Die 4 Rechenmethoden sollen Zufallszahlen generieren.
Und diese Zufallszahlen sollen ganzzahlig sein.
Also dann, lass uns Zufallszahlen anlegen.
Als Erstes muss diese Zufallszahl in einer Variablen gespeichert werden.
In meinem Beispiel-Code heißen die Variablen dafür „sumEins“ für den ersten Summanden.
Und „sumZwei“ für den zweiten Summanden.
Die Werte beider Variablen sollen ganzzahlig sein.
Deshalb speichere ich mir diese in einem Integer-Datentypen ab.
int sumEins = 0;
int sumZwei =0;
So die Variablen hast du.
Aber beide Variablen haben bis jetzt nur den Wert Null.
Wie bekommst du nun eine Zufallszahl da rein?
Die Java Klasse Math ist eine Standardklasse der Java API.
Und diese bietet eine Klassenmethode, namens Random an.
Die Methode erzeugt Zufallszahlen zwischen 0 und 1.
Also musst du in der Variablen den Rückgabewert der Random-Methode speichern.
int sumEins = Math.Random();
int sumZwei = Math.Random();
Jetzt steckt in den Variablen eine zufällige Kommazahl, zwischen 0 und 1.
Wenn du Zufallszahlen zwischen 0 und 100 haben möchtest, musst du diese Kommazahl mit 100 multiplizieren.
Das Ergebnis dieser Multiplikation ist dann irgendeine zufällige Kommazahl zwischen 0 und 100.
Am Beispiel:
- Die Zufallszahl lautet 0,0.
Du multiplizierst diese mit 100.
Das Ergebnis ist 0,0. - Die Zufallszahl lautet 0,8764.
Du multiplizierst mit 100.
Das Ergebnis ist 87,64. - Oder die Zufallszahl ist 1,0 – multipliziert mit 100 ergibt dann 100,0
int sumEins = (Math.random()*100);
int sumZwei = (Math.random()*100);
Du siehst aus den eigentlichen Zufallszahlen, welche zwischen 0 und 1 liegen – lassen sich beliebig große Zufallszahlen generieren.
Der Schlüssel dazu liegt in der Multiplikation.
Da aber die Zufallszahl, welche dir die Math.Random() bereitstellt eine Kommazahl ist – musst du diese noch in eine ganze Zahl ändern.
Wieso?
Du willst bei der Matheolympiade keine Aufgaben wie:
32,65 / 4,765 gestellt bekommen.
Nein -die Aufgabe soll lauten: 32 / 4.
Also abändern.
Du musst die Kommazahl in einen Integer-Datentypen casten / umwandeln.
Dazu schreibst du einfach (int) vor den Methodenaufruf.
int sumEins =(int)(Math.random()*100);
int sumZwei = (int)(Math.random()*100);
Somit hast du auch die Zufallszahlen.
Und diesen Java Code kannst du in allen 4 Rechenmethoden verwenden.
Beginnen wir mit der einfachsten Rechenmethode – der Addition.
Kommen wir zu den Methoden.
So legst du die Additions-Methode an.
Summand + Summand = Summe
Die Elemente einer Addition heißen Summanden und das Ergebnis nennt man Summe.
Die Methode addiere() soll jetzt zwei zufällige Summanden finden, welche miteinander addiert werden.
Aber wir stellen eine Bedingung an die Zufallszahlen.
Diese sollen im Wertebereich liegen.
Dazu wird das Argument „werteBereich“ mit der Zufallszahl verrechnet.
Erinnere dich:
Der Wertebereich wird in der „starteProgramm-Methode“ abgefragt und auch dort festgelegt.
Dann wird dieser Wert an die „generiereAufgabe()-Methode“ weitergegeben.
Und die generieren-Methode soll die einzelnen Rechenmethoden zufällig aufrufen und ihnen den Wertebereich übergeben.
Wenn du beispielsweise nur Aufgaben im Zahlenbereich 100 rechnen möchtest, dann gibst du diesen Wertebereich an.
Und es werden nur Zufallszahlen in diesem Zahlenbereich erzeugt.
So könnte die addieren-Methode aussehen:
import java.util.Scanner;
public class MatheOlympiade {
static int fehlerAnzahl;
static int aufgabenAnzahl;
static void starteProgramm(){
Scanner scanner = new Scanner (System.in);
System.out.println("Wie viele Aufgaben willst du lösen?");
aufgabenAnzahl=scanner.nextInt();
System.out.println("Gib den Wertebereich an!");
int werteBereich=scanner.nextInt();
//generiereAufgaben(werteBereich);
}
static void addiere(int werteBereich){
int sumEins =(int)(Math.random()*werteBereich);
int sumZwei = (int)(Math.random()*werteBereich);
int summe=sumEins+sumZwei;
}
public static void main(String[] args) {
starteProgramm();
}
}
Aber reicht das?
Ich denke nicht, denn…
Die Zufallszahl könnte für sumEins=70 und für sumZwei =60 sein.
Die Summe aus beiden Zufallszahlen wäre dann 130.
Und die Summe soll schließlich im Wertebereich liegen.
Du musst also, eine Programmstruktur schaffen, welche solange Zufallszahlen erzeugt bis die Summe aus beiden Zahlen gleich oder unter dem Wertebereich liegt.
Und das machst du mit einer Schleife.
Die Schleifenbedingung der while-Schleife lautet:
(summe >= werteBereich)
Im Rumpf der Schleife werden dann immer neue Zufallszahlen gebildet.
Und das macht die Schleife solange, bis die Abbruchbedingung der Schleife eintritt.
while (summe >= werteBereich){
sumEins =(int)Math.random()*werteBereich;
sumZwei = (int)Math.random()*werteBereich;
summe=sumEins+sumZwei;
Kümmern wir uns um den Rest.
Wenn das Programm läuft, wirst du aufgefordert die Summe aus zwei Zufallszahlen zu berechnen.
Und dein Ergebnis sollst du eingeben.
Der Code zur Eingabe lautet so:
int eingabe = scanner.nextInt();
Und diese Eingabe soll überprüft werden.
Eine Überprüfung machst du mit if und else Blöcken.
Die Bedingung, wenn deine Eingabe mit dem tatsächlichen Ergebnis nicht übereinstimmt lautet:
(summe != eingabe)
Und diesem Fall springt das Programm in den if – Block und führt diesen aus.
Im Falle einer falschen Eingaben bekommst:
Du dies über die Konsole mitgeteilt. System.out.println("Falsch");
Und der Wert, welcher in der Klassenvariable „fehlerAnzahl“ steckt, wird erhöht. fehlerAnzahl++;
Und so würde dann die addiere-Methode als Ganzes aussehen:
static void addiere(int werteBereich) {
int sumEins = (int) (Math.random() * werteBereich);//Zufallszahl im Wertebereich
int sumZwei = (int) (Math.random() * werteBereich);//Zweiter Summand ist ebenfalls im Wertebereich
int summe = sumEins + sumZwei;//Die Summe ist Summand + Summand
Scanner scanner = new Scanner(System.in);//Scanner-Objekt für die spätere Konsoleneeingabe
while (summe > werteBereich) { //solange die Summe größer als der Wertebereich ist, geht es in die Schleife
sumEins = (int) Math.random() * werteBereich;//In der Schleife wird eine neue Zufallszahl erstellt
sumZwei = (int) Math.random() * werteBereich;//Summand bekommt ebenfalls eine neue ZUfallszahl
summe = sumEins + sumZwei;//Summe wird bei jedem Schleifendurchlauf berechnet
}
System.out.println(sumEins + "+" + sumZwei);//Diese Aufgabenstellung erscheint dann auf der Konsole
int eingabe = scanner.nextInt();//Deine Eingabe wird gespeichert
if (summe != eingabe) {
fehlerAnzahl++;//Falls deine Eingabe nicht richtig ist wird der Wert erhöht
System.out.println("Falsch");//Feedback wird auf der Konsole ausgegegeben
} else {
System.out.println("Richtig");//Feedback bei richtiger Eingabe
}
}
Die Multiplizieren-Methode kannst du anlog zur Addieren-Methode schreiben.
Faktor * Faktor = Produkt.
Auch hier wird das Ergebnis geprüft.
In diesem Fall soll sich das Produkt im Wertebereich befinden.
Der komplette Code zu dieser Java Methode sieht dann so aus:
static void multipliziere(int werteBereich) {
int fakEins = (int) (Math.random() * werteBereich);//Zufallszahl Faktor 1 im Wertebereich
int fakZwei = (int) (Math.random() * werteBereich);//Zufallszahl für Faktor 2 im Wertebereich
int produkt = fakEins * fakZwei;//Berechnung des Produktes
Scanner scanner = new Scanner(System.in);//Scanner-Objekt für die Konsoleneingabe
while (produkt > werteBereich) { //Immer wenn das Produkt größer als der Wertebereich ist, gehts in die Schleife
fakEins = (int) (Math.random() * werteBereich);//Neue Zufallszahl für Faktor Eins
fakZwei = (int) (Math.random() * werteBereich);//Neue ZUfallszahl für Faktor Zwei
produkt = fakEins * fakZwei;//Neuberechnung des Produktes
}
System.out.println(fakEins + "*" + fakZwei);//Aufforderung zur Berechnung - Erscheint bei der Ausführung
int eingabe = scanner.nextInt();//Eingabe wird gespeichert
if (eingabe != produkt) {
System.out.println("Falsch");//Feedback, falls deine Eingabe falsch ist
fehlerAnzahl++;//Klassenvariable wird auch hier um eins erhöht
} else {
System.out.println("Richtig");//Feedback falls die Eingabe richtig ist
}
}
Bei der Subtraktionsmethode ist es etwas anders.
Denn du musst jetzt das Ergebnis prüfen – Dieses darf nicht negativ sein.
Somit muss der Minuend (erste Zahl) größer sein, als der Subtrahent.
Die Schleifenbedingung lautet somit:
subtrahent > minuend
Der Rest ist analog zu den beiden anderen Methoden.
static void subtrahiere(int werteBereich) {
int minuend = (int) (Math.random() * werteBereich);//Minuend im Wertebereich
int subtrahent = (int) (Math.random() * werteBereich);//Subtrahent im Wertebereich
int differenz = minuend - subtrahent;//Ermittlung der Differnz
Scanner scanner = new Scanner(System.in);//Neues Scannerobjekt
while (subtrahent > minuend) { //Solange der Subtrahent kleiner als der Minuend ist - gehts in die Schleife
minuend = (int) (Math.random() * werteBereich);//neue Zufallszahl für den Minuend
subtrahent = (int) (Math.random() * werteBereich);//neue Zufallszahl für den Subtrahent
differenz = minuend - subtrahent;//Ermittlung der Differnz
}
System.out.println(minuend + "-" + subtrahent);//Aufforderung zur Berechnung
int eingabe = scanner.nextInt();//Eingabe wird gespeichert
if (eingabe != differenz) { //Eingabe wird verglichen
System.out.println("Falsch");//Feedback falls EIngabe falsch
fehlerAnzahl++; //Wert der Variablen erhöht sich
} else {
System.out.println("Richtig");//Feedback falls deine Eingabe richtig ist
}
}
Die letzte Rechenmethode ist die Division.
Auch hier wird das Ergebnis geprüft.
Eine Division durch null ist mathematisch nicht möglich.
Das Programm würde dann einen Fehler verursachen.
Das bedeutet, dass die Zufallszahl bei 1 beginnt.
int divisor = (int) (Math.random() * werteBereich) + 1;
Außerdem soll das Programm keine Rechenaufgaben erzeugen, bei denen das Ergebnis ein Bruch ist.
Somit lautet die Schleifenbedingung:
(divident % divisor != 0)
Der Rest ist analog zu den anderen Rechenmethoden.
static void dividiere(int werteBereich) {
int divident = (int) (Math.random() * werteBereich);//ZUfallszahl für den Divident
int divisor = (int) (Math.random() * werteBereich) + 1;//Divisor 0 ist nicht möglich
int quotient = divident / divisor;//Quotient wird ermittelt
Scanner scanner = new Scanner(System.in);//Scanner-Objekt für spätere Eingabe
while (divident % divisor != 0) {
divident = (int) (Math.random() * werteBereich);//Neue ZUfallszahl für den Divident
divisor = (int) (Math.random() * werteBereich) + 1;//Zufallszahl beginnt auch hier bei 1
quotient = divident / divisor;//Quotient wird neu gespeichert
}
System.out.println(divident + "/" + divisor);//Aufgabenstellung für die Konsole
int eingabe = scanner.nextInt();//Eingabe wird gespeichert
if (eingabe != quotient) {
System.out.println("Falsch");//Feedback falls Eingabe falsch
fehlerAnzahl++;//Fehleranzahl wird um eins erhöht
} else {
System.out.println("Richtig");//Feedback falls Eingabe richtig ist
}
}
Das Herzstück des Programmes ist die generieren()-Methode.
Diese Methode soll dann alle 4 Rechenmethoden in einer zufälligen Reihenfolge aufrufen.
Und zwar sooft, wie es in der Klassen-Variablen „aufgabenAnzahl“ gespeichert wurde.
Wie könnte man dies jetzt umsetzen?
Vielleicht so…
- Erzeugen einer Zufallszahl zwischen 0 und 3.
- Wenn der Wert 0 ist dann wird die addieren-Methode ausgeführt.
- Wenn der Wert 1 ist, dann die Subtraktion.
- Bei 2 eben Multiplikation.
- Und schließlich bei 3 die Division.
Gesagt getan…
static void generiereAufgaben(int werteBereich) {
int bereich = (int) (Math.random() * 3);//ZUfallszahl zwischen 0 und 3
switch (bereich) {
case 0:
System.out.println("Addition");//Konsolenausgabe was gemacht werden soll
addiere(werteBereich);//Aufruf der Addieren-Methode und Übergabe des Wertebereichs
break;
case 1:
System.out.println("Subtraktion");
subtrahiere(werteBereich);
break;
case 2:
System.out.println("Multipliziere");
multipliziere(werteBereich);
break;
default:
System.out.println("Dividiere");
dividiere(werteBereich);
break;
}
}
}
Jetzt würde das Ganze einmal stattfinden.
Es würde eine Zufallszahl zwischen 0 und 3 generiert werden.
Das Programm hakt in den entsprechenden Case ein.
Und es würde dann eine zufällige Rechenaufgabe gestellt werden.
Jetzt musst du nur noch ein Konstrukt schaffen, welches dies beliebig oft wiederholt.
Jawohl – Eine Schleife.
Und welche Art von Schleife?
Die Anzahl der Durchläufe ist bekannt.
Den Wert speicherst du in der Klassenvariablen „aufgabenAnzahl“.
Und wenn die Anzahl der Durchläufe bekannt ist, nutze immer eine for-Schleife.
Der Schleifenzähler könnte bei 0 starten.
Also int i =0.
Aber du könntest diesen auch bei 1 starten lassen.
Und bei jedem Durchlauf lässt du dir die Aufgabenanzahl (1.Aufgabe, 2.Aufgabe usw.) anzeigen.
Ist doch besser oder?
Die Abbruchbedingung der Schleife würde im Falle i=1 lauten:
i <= aufgabenAnzahl
Somit sieht der Kopf der Schleife so aus:
(int i = 1; i <= aufgabenAnzahl; i++)
Und im Rumpf kommen dann nur noch die switch case Anweisung, welche du bereits hast.
Also dann.
Der komplette Code der "generiereAufgaben"-Methode würde so aussehen.
static void generiereAufgaben(int werteBereich) {
int bereich = 0;//Lokale Variable mit Startwert 0
for (int i = 1; i <= aufgabenAnzahl; i++) {
bereich = (int) (Math.random() * 4);//Zufallszahl bei jedem Schleifendurchlauf
System.out.println(i + ".Aufgabe");//Ausgabe der jeweiligen Aufgabe
switch (bereich) {
case 0:
System.out.println("Addition");
addiere(werteBereich);
break;
case 1:
System.out.println("Subtraktion");
subtrahiere(werteBereich);
break;
case 2:
System.out.println("Multipliziere");
multipliziere(werteBereich);
break;
default:
System.out.println("Dividiere");
dividiere(werteBereich);
break;
}
}
gibInfo();
}
Du siehst es schon.
Nachdem die komplette Schleife durchlaufen wurde, wírd die gibInfo()-Methode aufgerufen.
Die letzte Methode soll nur Informationen geben.
Diese Methode nutzt die Klassenvariable "fehlerAnzahl".
Und gibt den Wert auf der Konsole aus.
static void gibInfo(){
System.out.println("Fehleranzahl: "+fehlerAnzahl);
}
So das wars.
Hier ist die komplette Lösung zu dieser Java Übung
import java.util.Scanner;//Importanweisung für Scanner
public class MatheOlympiade {
static int fehlerAnzahl;//KLassenvariable soll von allen 4 Rechenmethoden genutzt werden
static int aufgabenAnzahl;//Aufgabenanzahl wird in der Start-Methode festgelegt und in der generieren-Methode genutzt
static void starteProgramm() {
Scanner scanner = new Scanner(System.in);
System.out.println("Wie viele Aufgaben willst du lösen?");
aufgabenAnzahl = scanner.nextInt();//Anzahl der Aufgaben wird in Klassenvariable gespeichert
System.out.println("Gib den Wertebereich an!");
int werteBereich = scanner.nextInt();//Wertebereich wird in lokaler Variabler gespeichert
generiereAufgaben(werteBereich);//Methode wird aufgerufen und Wertebereich wird übergeben
}
static void gibInfo() {
System.out.println("Fehleranzahl: " + fehlerAnzahl);//Konsolenausgabe zur Klassenvariable Fehleranzahl
}
static void generiereAufgaben(int werteBereich) {
int bereich = 0;//lokale Variable speichert die Zufallszahl
for (int i = 1; i <= aufgabenAnzahl; i++) {
bereich = (int) (Math.random() * 3);//Zufallszahl wird jedes Mal neu ermittelt
System.out.println(i + ".Aufgabe");//Konsolenausgabe zur Aufgabenanzahl 1., 2., 3. usw.
switch (bereich) {
case 0:
System.out.println("Addition");//Aufforderung zur Berechnung
addiere(werteBereich);//addieren-Methode wird aufgerufen und Wertebereich wird übergeben
break;
case 1:
System.out.println("Subtraktion");//Aufforderung zur Subtraktion
subtrahiere(werteBereich);//subtrahieren-Methode wird aufgerufen und Wertebereich wird übergeben
break;
case 2:
System.out.println("Multipliziere");//Aufforderung zur Multiplikation
multipliziere(werteBereich);//multiplizieren-Methode wird aufgerufen und Wertebereich wird übergeben
break;
default:
System.out.println("Dividiere");//Aufforderung zur Division
dividiere(werteBereich);//Dividiere-Methode wird aufgerufen und Wertebereich wird übergeben
break;
}
}
gibInfo();//Nachdem Schleife komplett durchlaufen wurde, wird die gibInfo() Methode aufgerufen
}
static void addiere(int werteBereich) {
int sumEins = (int) (Math.random() * werteBereich);//Zufallszahl für Summand Eins
int sumZwei = (int) (Math.random() * werteBereich);//Zufallszahl für Summand Zwei
int summe = sumEins + sumZwei;//Summe = Summand + Summand
Scanner scanner = new Scanner(System.in);//Scanner-Objekt mit Referenzvariable scanner
while (summe >= werteBereich) {
sumEins = (int) Math.random() * werteBereich;//neue Zufallszahl
sumZwei = (int) Math.random() * werteBereich;//neue ZUfallszahl
summe = sumEins + sumZwei;//neue Summe
}
System.out.println(sumEins + "+" + sumZwei);//Konsolenanweisung
int eingabe = scanner.nextInt();//Eingabe wird durch die Referenzvariable Scanner gespeichert
if (summe != eingabe) {
fehlerAnzahl++;//Fehleranzahl wird erhöht
System.out.println("Falsch");//Feedback falls Ergbebnis falsch ist
} else {
System.out.println("Richtig");//Feedback, falls Ergebnis richtig ist
}
}
static void subtrahiere(int werteBereich) {
int minuend = (int) (Math.random() * werteBereich);
int subtrahent = (int) (Math.random() * werteBereich);
int differenz = minuend - subtrahent;
Scanner scanner = new Scanner(System.in);
while (subtrahent > minuend) {
minuend = (int) (Math.random() * werteBereich);
subtrahent = (int) (Math.random() * werteBereich);
differenz = minuend - subtrahent;
}
System.out.println(minuend + "-" + subtrahent);
int eingabe = scanner.nextInt();
if (eingabe != differenz) {
System.out.println("Falsch");
fehlerAnzahl++;
} else {
System.out.println("Richtig");
}
}
static void multipliziere(int werteBereich) {
int fakEins = (int) (Math.random() * werteBereich);
int fakZwei = (int) (Math.random() * werteBereich);
int produkt = fakEins * fakZwei;
Scanner scanner = new Scanner(System.in);
while (produkt > werteBereich) {
fakEins = (int) (Math.random() * werteBereich);
fakZwei = (int) (Math.random() * werteBereich);
produkt = fakEins * fakZwei;
}
System.out.println(fakEins + "*" + fakZwei);
int eingabe = scanner.nextInt();
if (eingabe != produkt) {
System.out.println("Falsch");
fehlerAnzahl++;
} else {
System.out.println("Richtig");
}
}
static void dividiere(int werteBereich) {
int divident = (int) (Math.random() * werteBereich);
int divisor = (int) (Math.random() * werteBereich) + 1;//Null als Zufallszahl wird ausgeschlossen
int quotient = divident / divisor;
Scanner scanner = new Scanner(System.in);
while (divident % divisor != 0) {
divident = (int) (Math.random() * werteBereich);
divisor = (int) (Math.random() * werteBereich) + 1;//Zufallszahl ist größer Null
quotient = divident / divisor;
}
System.out.println(divident + "/" + divisor);
int eingabe = scanner.nextInt();
if (eingabe != quotient) {
System.out.println("Falsch");
fehlerAnzahl++;
} else {
System.out.println("Richtig");
}
}
public static void main(String[] args) {
starteProgramm();
}
}
Über den Autor
