Skip to main content

Java Übung & Lösung: Eingaben über Schleifenstruktur auswerten


java übung lösung bildschirmeingaben schleife auswerten

In dieser Java Übung geht es um Schleifen.
Und zwar möchte ich, dass du eine virtuelle Geldruckmaschine erstellst.

Was meine ich damit?
Du gibst in der Konsole einen x-beliebigen Betrag ein und das Programm gibt dir virtuelle Geldscheine zurück.

Ein Beispiel:
Du gibst die Zahl 400 ein.
Dann liefert dir das Programm 2 x 200 Euro-Scheine.

Und was soll das Ganze bringen?
Ich möchte, dass das Programm die kleinste Menge an Scheinen produziert.

Wenn du zum Beispiel 1000 Euro eingibst.

  • Dann kann das Programm dir 200 x 5 Euro Scheine liefern
  • Oder 100 x 10 Euro Scheine
  • Oder 50 x 20 Euro Scheine
  • Oder 10 x 100 Euro Scheine
  • Oder 5 x 200 Euro Scheine
  • Aber auch 2 x 500 Euro Scheine.

Und die letzte Ausgabe wäre die einzig Richtige.

  • Erstelle eine Klasse „GeldDruck“ und implementiere eine statische parameterlose Methode „druckeGeld“.
  • Diese Methode fordert dich auf, einen ganzzahligen Betrag einzugeben.
  • Und dann liefert dir die Methode eine Bildschirmausgabe mit allen Geldscheinangaben zurück.
  • Beachte bitte, dass diese Geldscheine größtmöglich sein sollten.
    Du willst nämlich nicht 200 mal 5 Euro Scheine in der Hand halten.
  • Rufe diese Methode in der main-Methode der Klasse auf.
    Und prüfe dann die Banknotenausgabe mit der Zahl 795 Euro.

Bevor du loslegst, hier die möglichen Banknoten:

  • 5 Euro
  • 10 Euro
  • 20 Euro
  • 50 Euro
  • 100 Euro
  • 200 Euro
  • 500 Euro

Also dann viel Spaß mit dieser Java Übung.


Welche Schleife solltest du zur Lösung dieser Java Übung verwenden?

Die Anzahl der Schleifendurchläufe ist ungewiss.
Somit ist eine for-Schleife eher unpraktisch.

Also fällt die Wahl auf eine While Schleife.

Wie könnte jetzt die Schleifenbedingung aussehen?
Du hast einen Betrag von 795 Euro und dieser wird solange gesplittet bzw. in Geldscheinen aufgeteilt – bis dieser Null ist.
Somit könnte die Schleifenbedingung so aussehen:
betrag !=0

Du musst aber noch schlechte Nutzereingaben abfangen.
Und zwar können nur Beträge ausgegeben werden, welche durch 5 teilbar sind.
792 Euro würde somit nicht funktionieren.
betrag % 5 ==0

Auch Minusbeträge sollten nicht akzeptiert werden.
Die zweite Bedingung wäre somit:
betrag > 0

Das Grundgerüst der Klasse und der enthaltenen Methode würde so aussehen:


import java.util.Scanner;

public class GeldDruck {

	static void druckeGeld() {
		Scanner eingabe = new Scanner(System.in);
		System.out.println("Gib einen Betrag ein!");
		int betrag = eingabe.nextInt();

		if (betrag % 5 == 0 && betrag > 0) {
			while (betrag != 0) {
				//Zerlege den Betrag in entsprechende Geldscheine
			}
		} else {
			System.out.println("Betrag ungültig!");//Fehlermeldung
			druckeGeld();//Bei ungültigen Werten wird die Methode wieder aufgerufen
		}
	}

	public static void main(String[] args) {
		druckeGeld();//Methodenaufruf
	}
}
  • Die If-Verzweigung fängt die Nutzereingabe ab.
  • Falls diese korrekt ist, wird die Schleife ausgeführt.
  • Wenn die Benutzereingabe nicht korrekt ist, springt das Programm in den else Block und führt diesen aus.
    Dazu wird im else-Block eine Fehlermeldung produziert und dann startet die Methode neu.

Im Schleifenrumpf steht bis jetzt nur ein Kommentar zur Erläuterung, was da noch rein soll.

Lass uns das ändern.

Im Schleifenrumpf arbeitest du dann mit Schwellenwerten.

Schwellenwerte – was ist das?
Die Schwellenwerte sind die Banknoten.

In unserem Beispiel würdest du den Wert 795 übergeben.
Das heißt dann:

  • Erster Schwellenwert 500 Euro-Schein.
  • Das Programm produziert den ersten 500 Euro-Schein.
  • Die Variable für die Anzahl der 500-Euroscheine erhöht sich um eins.
  • Gleichzeitig wird der Wert 500 von 795 Euro abgezogen.

Es bleiben 295 Euro Restbetrag.

  • Die Schleife startet mit 295 Euro Restbetrag neu.
  • Und jetzt sucht die Schleife den nächsten Schwellenwert.
    Dieser liegt beim 200 Euro-Schein.
    Also wird hier eingehakt.
  • Die Variable für die 200-Euro-Scheine erhöht sich ebenfalls um eins.
  • Der Restbetrag liegt dann bei 95 Euro.

Der nächste Schwellenwert wären 50 Euro.
Usw.

Du benötigst somit in der Schleife wieder Programmstrukturen, welche Werte abfangen.
Und Werte abfangen, machst du mit if und else Blöcken.

Außerdem brauchst du für jeden Euroschein eine Variable, welche die Anzahl speichert.

Und so geht’s.


import java.util.Scanner;

public class GeldDruck {

	static void druckeGeld() {
		Scanner eingabe = new Scanner(System.in);
		System.out.println("Gib einen Betrag ein!");
		int betrag = eingabe.nextInt();
		int fuenfHunderter = 0;// speichert die Anzahl der 500-Euro-Scheine
		int zweiHunderter = 0;// speichert die Anzahl der 200-Euro-Scheine
		int einHunderter = 0;// speichert die Anzahl der 100-Euro-Scheine
		int fuenfziger = 0;// speichert die Anzahl der 50-Euro-Scheine
		int zwanziger = 0;// speichert die Anzahl der 20-Euro-Scheine
		int zehner = 0;// speichert die Anzahl der 10-Euro-Scheine
		int fuenfer = 0;// speichert die Anzahl der 5-Euro-Scheine

		if (betrag % 5 == 0 && betrag > 0) {
			while (betrag != 0) {
				if (betrag >= 500) {
					fuenfHunderter++;// Variable wird um eins erhöht
					betrag = betrag - 500;// Betrag wird um 500 Euro verringert
				} else if (betrag >= 200) {
					zweiHunderter++;
					betrag = betrag - 200;
				} else if (betrag >= 100) {
					einHunderter++;
					betrag = betrag - 100;
				} else if (betrag >= 50) {
					fuenfziger++;
					betrag = betrag - 50;
				} else if (betrag >= 20) {
					zwanziger++;
					betrag = betrag - 20;
				} else if (betrag >= 10) {
					zehner++;
					betrag = betrag - 10;
				} else if (betrag >= 5) {
					fuenfer++;
					betrag = betrag - 5;
				}
			}//Schleifenende
		} else {
			System.out.println("Betrag ungültig!");// Fehlermeldung
			druckeGeld();// Bei ungültigen Werten wird die Methode wieder aufgerufen
		}
		System.out.println(fuenfHunderter + " mal 500 Euro-Scheine");
		System.out.println(zweiHunderter + " mal 200 Euro-Scheine");
		System.out.println(einHunderter + " mal 100 Euro-Scheine");
		System.out.println(fuenfziger + " mal 50 Euro-Scheine");
		System.out.println(zwanziger + " mal 20 Euro-Scheine");
		System.out.println(zehner + " mal 10 Euro-Scheine");
		System.out.println(fuenfer + " mal 5 Euro-Scheine");
	}

	public static void main(String[] args) {
		druckeGeld();
	}
}

Im Grunde genommen, ist dies die komplette Lösung zu dieser Java Aufgabe.

Eine kleine Schönheitskorrektur in der Methode solltest du noch vornehmen.

Versuch doch einmal bitte der Methode zuerst einen falschen Wert, wie 792 Euro und dann einen richtigen Wert 1000 Euro zu übergeben.

Was passiert?
Die Schleife bzw. die Bildschirmausgaben werden zweimal gedruckt.

Wieso?
Die Methode ruft sich selbst auf.
Das bedeutet nicht, dass die alte Methode beendet ist.

Java-Übung-Gelddruck-Methodenstack

Auf dem Stack, dem Speicherort für Methoden – liegt die Methode „druckeGeld“ zweimal.
Einmal mit lokalen Variablen und deren berechneten Werten.
Und einmal mit lokalen Variable und deren default-Werten.
Im Falle Integer sind diese Null.

Die Anweisung für die Konsolenausgaben erscheinen dennoch beide.

Du musst also eine beenden, bevor du die andere Methode aufrufst.
Und dies machst du mit der Anweisung System.exit(1).

Wofür steht das Argument 1?
Du kannst der Anweisung / Methode einen Parameter übergeben.
Dadurch kannst du später auswerten, wieso es zum Exit kam.

Für dich spielt das in diesem Beispiel keine Rolle.
Du kannst der Methode also auch Werte, wie 2, 15 oder 1.000 übergeben.


import java.util.Scanner;

public class GeldDruck {

	static void druckeGeld() {
		Scanner eingabe = new Scanner(System.in);
		System.out.println("Gib einen Betrag ein!");
		int betrag = eingabe.nextInt();
		int fuenfHunderter = 0;// speichert die Anzahl der 500-Euro-Scheine
		int zweiHunderter = 0;// speichert die Anzahl der 200-Euro-Scheine
		int einHunderter = 0;// speichert die Anzahl der 100-Euro-Scheine
		int fuenfziger = 0;// speichert die Anzahl der 50-Euro-Scheine
		int zwanziger = 0;// speichert die Anzahl der 20-Euro-Scheine
		int zehner = 0;// speichert die Anzahl der 10-Euro-Scheine
		int fuenfer = 0;// speichert die Anzahl der 5-Euro-Scheine

		if (betrag % 5 == 0 && betrag > 0) {
			while (betrag != 0) {
				if (betrag >= 500) {
					fuenfHunderter++;// Variable wird um eins erhöht
					betrag = betrag - 500;// Betrag wird um 500 Euro verringert
				} else if (betrag >= 200) {
					zweiHunderter++;
					betrag = betrag - 200;
				} else if (betrag >= 100) {
					einHunderter++;
					betrag = betrag - 100;
				} else if (betrag >= 50) {
					fuenfziger++;
					betrag = betrag - 50;
				} else if (betrag >= 20) {
					zwanziger++;
					betrag = betrag - 20;
				} else if (betrag >= 10) {
					zehner++;
					betrag = betrag - 10;
				} else if (betrag >= 5) {
					fuenfer++;
					betrag = betrag - 5;
				}
			}//Schleifenende
		} else {
			System.out.println("Betrag ungültig!");// Fehlermeldung
			druckeGeld();// Bei ungültigen Werten wird die Methode wieder aufgerufen
			System.exit(1);//Aktuelle Methode beenden und vom Stack entfernen
		}
		System.out.println(fuenfHunderter + " mal 500 Euro-Scheine");
		System.out.println(zweiHunderter + " mal 200 Euro-Scheine");
		System.out.println(einHunderter + " mal 100 Euro-Scheine");
		System.out.println(fuenfziger + " mal 50 Euro-Scheine");
		System.out.println(zwanziger + " mal 20 Euro-Scheine");
		System.out.println(zehner + " mal 10 Euro-Scheine");
		System.out.println(fuenfer + " mal 5 Euro-Scheine");
	}

	public static void main(String[] args) {
		druckeGeld();
	}
}

Ähnliche Beiträge