Skip to main content

Java Übung 25 – Simuliere eine Gelddruckmaschine

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

Java Vererbung findet auch zwischen Einkaufstüten und Polizeiautos statt

Java Vererbung

„Manchmal findet Java Vererbung auch zwischen Einkaufstüten und Polizeiautos statt“ Irrer Titel, oder? Aber mal Hand aufs Herz. Was haben eigentlich eine Einkaufstüte und ein Polizeiwagen gemeinsam? Ich verrate dir etwas: Du kannst die Verbindung nicht erkennen, denn ich habe dir nicht alles verraten. Es fehlt noch ein wichtiger Aspekt – eine Verbindung zwischen beiden. […]

Java for Schleifen schachteln – So funktioniert es

Java For Schleifen schachteln

Diese Situation kennst du doch auch…. Du stehst an der Haltestelle und wartest auf den Bus. Dein Blick fällt auf die Uhr.   Oder du wartest an der Ecke auf deinen Freund oder Kollegen. Immer wieder schaust du auf deine Uhr.   Sie ist kaum noch wegzudenken. Die mobile Taschenuhr.   Lange Zeit wurde die […]

Sicherer Schleifendurchlauf mit Do while Schleife

Java Do While Schleife

Es ist doch eigentlich so: Immer wenn du die Anzahl der Schleifendurchläufe nicht kennst, nutzt du in deinen Java Programmen while Schleifen. Doch Java bietet dir neben der While Schleife einen weiteren Schleifentyp an. Diese nennt sich do while Schleife. Was kann die? Eigentlich genau das Gleiche, wie die while Schleife. Mit einem kleinen aber […]

Der bedeutende Unterschied zwischen Klassenvariablen und Instanzvariablen

Java Klassenvariablen

Bei der Java Programmierung unterscheidet man drei Arten von Variablen. Als erste Gruppe sind die lokalen Variablen zu nennen. Auf diese gehe ich in einem separaten Artikel ein. Mich interessieren die zwei anderen Variablentypen. Zum einen existieren Klassenvariablen. Und dann sind da noch die Instanzvariablen. Wo liegt der Unterschied? Instanzvariablen stehen einem Objekt zur Verfügung. […]

So kannst du dein Java Programm mit der main Methode ausführen

Auf zum ersten Java Programm. Vielleicht fragst du dich jetzt gerade: Na, was haben wir denn bisher gemacht? War das etwa kein Java Programm? Wir haben bisher nur eine Klasse „Human“ für ein zuküntfiges Mensch-Objekt erstellt. Diesem Objekt haben wir eine Instanzvariable, namens size (Größe) zugeordnet. Und wir haben eine Instanzmethode, namens grow (wachsen) geschrieben. […]

So legst du Utility Klassen in Java an

Java Utility Klassen

Utility Java Klassen – was ist das? Man nennt diese auch Hilfsklassen von Java. Diese Utility Klassen sind Java Klassen, welche lediglich Methoden und Konstanten anbieten. Am Beispiel: Die Klasse Math ist so eine klassische Utility Klasse. Wozu braucht man solche Klassen? Diese Klassen sind so etwas wie ein Werkzeugkoffer für jedes Java Programm. Hier […]

3 Möglichkeiten – Java Strings verketten und zusammenfügen

Java Strings verketten

Kennst du dieses Relikt längst vergangener Tage? Ein Brief. Ja früher einmal war es üblich, Briefe zu schreiben. Lange bevor es Smartphones oder Email gab. Man stelle sich einmal vor…. Die Leute mussten sich hinsetzen mit einem Blatt und einem Stift – und richtig schreiben. Nein nicht tippen – schreiben. 🙂 Grausame Welt, oder? Aber […]

So lassen sich Java Strings in char zerlegen

Java Strings zerlegen char

Java Strings sind Zeichenketten. Und diese Zeichenketten lassen sich aufsplitten und in ihre Einzelteile zerlegen. Ich möchte dir in diesem Beitrag Möglichkeiten vorstellen, wie du Strings in Character-Datentypen zerlegen, extrahieren und die Einzelteile in Arrays speichern kannst.

8 Java Datentypen, die du kennen solltest

Java Datentypen

Java Datentypen Ich gebe zu, ich hasse dieses Thema. Denn es ist eigentlich nichts weiter als graue Theorie. Dennoch müssen wir dieses Thema behandeln. Um schnell in das Thema zu kommen, stelle ich dir eine Übersicht aller primitiven Datentypen zur Verfügung. Wieso primitive? Es gibt außer den primitiven Datentypen, noch Referenztypen. Und diese Referenztypen sind […]

So kannst du ein Java Programm starten und Argumente übergeben

Um ein Java Programm starten zu können, benötigst du immer die main-Methode. Das Programm startet immer genau an dieser Stelle. Alle lokalen Variablen, welche du in der Main Methode anlegst, kannst du dann im Programm nutzen. Auch alle Methoden, welche du innerhalb des Methodenrumpfes der main-Methode aufrust, werden ausgeführt. Was ist aber vor der main-Methode. […]